Rework reading content for chunked responses (#294)

Author: KlausVcb

nanoFramework.System.Net.Http.Client/System.Net.Http.Client.nfproj

@@ -111,6 +111,9 @@
     <Compile Include="..\nanoFramework.System.Net.Http\Http\System.Net.Http.Constants.cs">
       <Link>Http\System.Net.Http.Constants.cs</Link>
     </Compile>
+    <Compile Include="..\nanoFramework.System.Net.Http\Http\System.Net.IKnowWhenDone.cs">
+      <Link>Http\System.Net.IKnowWhenDone.cs</Link>
+    </Compile>
     <Compile Include="..\nanoFramework.System.Net.Http\Http\System.Net.Internal.WebRequestPrefixElement.cs">
       <Link>Http\System.Net.Internal.WebRequestPrefixElement.cs</Link>
     </Compile>

nanoFramework.System.Net.Http.Server/System.Net.Http.Server.nfproj

@@ -64,6 +64,9 @@
     <Compile Include="..\nanoFramework.System.Net.Http\Http\System.Net.HttpVersion.cs">
       <Link>Http\System.Net.HttpVersion.cs</Link>
     </Compile>
+    <Compile Include="..\nanoFramework.System.Net.Http\Http\System.Net.IKnowWhenDone.cs">
+      <Link>Http\System.Net.IKnowWhenDone.cs</Link>
+    </Compile>
     <Compile Include="..\nanoFramework.System.Net.Http\Http\System.Net.Internal.cs">
       <Link>Http\System.Net.Internal.cs</Link>
     </Compile>

nanoFramework.System.Net.Http/Http/Headers/HttpContentHeaders.cs

@@ -38,11 +38,6 @@ public long ContentLength
                     }
                 }
 
-                if (_content.TryComputeLength(out long contentLength))
-                {
-                    return contentLength;
-                }
-
                 return -1;
             }
 

nanoFramework.System.Net.Http/Http/HttpClientHandler.cs

@@ -330,19 +330,15 @@ HttpResponseMessage CreateResponseMessage(HttpWebResponse wr, HttpRequestMessage
                 ReasonPhrase = wr.StatusDescription
             };
 
-            // get response stream
-            var responseStream = wr.GetResponseStream();
-
             // set content
-            response.Content = new StreamContent(
-                responseStream,
-                (int)responseStream.Length);
+            response.Content = new StreamContent(wr.GetResponseStream());
 
             var headers = wr.Headers;
 
             foreach (var headerKey in headers.AllKeys)
             {
                 response.Headers._headerStore.AddInternal(headerKey, headers[headerKey]);
+                response.Content.Headers._headerStore.AddInternal(headerKey, headers[headerKey]);
             }
 
             requestMessage.RequestUri = wr.ResponseUri;

nanoFramework.System.Net.Http/Http/HttpContent.cs

@@ -41,6 +41,11 @@ public HttpContentHeaders Headers
             }
         }
 
+        /// <summary>
+        /// Contains the actual bytes read into the buffer
+        /// </summary>
+        protected int TotalBytesRead { get; set; }
+
         /// <summary>
         /// Initializes a new instance of the HttpContent class.
         /// </summary>
@@ -105,6 +110,11 @@ public Stream LoadIntoBuffer()
 
             SerializeToStream(_buffer);
 
+            if (TotalBytesRead > 0)
+            {
+                _buffer.SetLength(TotalBytesRead);
+            }
+
             _buffer.Seek(0, SeekOrigin.Begin);
 
             return _buffer;

nanoFramework.System.Net.Http/Http/StreamContent.cs

@@ -27,7 +27,7 @@ public class StreamContent : HttpContent
         /// The <see cref="StreamContent"/> object calls <see cref="Dispose"/> on the provided Stream object when <see cref="StreamContent.Dispose"/> is called.
         /// </remarks>
         public StreamContent(Stream content)
-        : this(content, 16 * 1024)
+        : this(content, 4 * 1024)
         {
         }
 
@@ -81,12 +81,24 @@ protected override void SerializeToStream(Stream stream)
             byte[] buffer = new byte[2048];
             int read;
             int totalRead = 0;
+            int contentLength = (int)Headers.ContentLength;
 
-            while (totalRead < _bufferSize)
+            // occurrs when there is not Content_Length header (i.e. chunked response)
+            if (contentLength < 0)
+            {
+                contentLength = int.MaxValue;
+            }
+
+            while (totalRead < contentLength)
             {
                 read = _content.Read(buffer, 0, buffer.Length);
 
-                if (read == 0)
+                if (_content is IKnowWhenDone knowWhenDone && knowWhenDone.IsDone)
+                {
+                    //happens when a chunked response is at the end
+                    break;
+                }
+                else if (read == 0)
                 {
                     // need to let the native layer get more data
                     Thread.Sleep(10);
@@ -97,6 +109,8 @@ protected override void SerializeToStream(Stream stream)
                     stream.Write(buffer, 0, read);
                 }
             }
+
+            TotalBytesRead = totalRead;
         }
 
         /// <inheritdoc/>

nanoFramework.System.Net.Http/Http/System.Net.IKnowWhenDone.cs

@@ -0,0 +1,23 @@
+//
+// Copyright (c) .NET Foundation and Contributors
+// Portions Copyright (c) Microsoft Corporation.  All rights reserved.
+// See LICENSE file in the project root for full license information.
+//
+
+
+namespace System.Net
+{
+    /// <summary>
+    /// The interface to let its consumer know work is done
+    /// </summary>
+    internal interface IKnowWhenDone
+    {
+        /// <summary>
+        /// The property reflects if work is done
+        /// </summary>
+        /// <returns>
+        /// True when work is done.
+        /// </returns>
+        bool IsDone { get; }
+    }
+}

nanoFramework.System.Net.Http/Http/System.Net._InputNetworkStreamWrapper.cs

@@ -16,10 +16,10 @@ namespace System.Net
     /// The InputNetworkStreamWrapper is used to re-implement calls to  NetworkStream.Read
     /// It has internal buffer and during initial read operation it places available data from socket into buffer.
     /// Later it releases data to Stream.Read calls.
-    /// It also provides direct access to bufferet data for internal code. 
+    /// It also provides direct access to buffered data for internal code. 
     /// It provides possibility to "unread" or probe data - meaning user can read byte of data and then return it back to stream.
     /// </summary>
-    internal class InputNetworkStreamWrapper : Stream
+    internal class InputNetworkStreamWrapper : Stream, IKnowWhenDone
     {
         static private Text.Decoder  UTF8decoder  = System.Text.Encoding.UTF8.GetDecoder();
         static private Text.Encoding UTF8Encoding = System.Text.Encoding.UTF8;
@@ -200,6 +200,7 @@ public override int Read(byte[] buffer, int offset, int size)
             if (m_chunk.m_Size == 0)
             {
                 // Nothing to read and actually it is the end of the message body. It is "case 4".
+                IsDone = true;
                 return 0;
             }
 
@@ -456,6 +457,8 @@ public override int WriteTimeout
             set { m_Stream.WriteTimeout = value; }
         }
 
+        public bool IsDone { get; private set; }
+
         public Stream CloneStream()
         {
             InputNetworkStreamWrapper clone = this.MemberwiseClone() as InputNetworkStreamWrapper;

nanoFramework.System.Net.Http/System.Net.Http.nfproj

@@ -63,6 +63,7 @@
     <Compile Include="Http\HttpResponseMessage.cs" />
     <Compile Include="Http\StreamContent.cs" />
     <Compile Include="Http\StringContent.cs" />
+    <Compile Include="Http\System.Net.IKnowWhenDone.cs" />
     <Compile Include="Http\System.Net.Http.Constants.cs" />
     <Compile Include="Http\System.Net.AuthenticationType.cs" />
     <Compile Include="Http\System.Net.HttpListener.cs" />