Implement HttpWebRequest AllowWriteStreamBuffering property

src/libraries/System.Net.Requests/src/System.Net.Requests.csproj

@@ -29,6 +29,7 @@
     <Compile Include="System\Net\IWebRequestCreate.cs" />
     <Compile Include="System\Net\ProtocolViolationException.cs" />
     <Compile Include="System\Net\RequestStream.cs" />
+    <Compile Include="System\Net\RequestBufferingStream.cs" />
     <Compile Include="System\Net\TaskExtensions.cs" />
     <Compile Include="System\Net\WebException.cs" />
     <Compile Include="System\Net\WebExceptionStatus.cs" />
@@ -48,7 +49,6 @@
     <Compile Include="System\Net\NetRes.cs" />
     <Compile Include="System\Net\NetworkStreamWrapper.cs" />
     <Compile Include="System\Net\TimerThread.cs" />
-    <Compile Include="System\Net\HttpClientContentStream.cs" />
     <Compile Include="System\Net\RequestStreamContent.cs" />
     <Compile Include="System\Net\Cache\HttpCacheAgeControl.cs" />
     <Compile Include="System\Net\Cache\HttpRequestCacheLevel.cs" />
@@ -87,10 +87,6 @@
              Link="Common\System\Net\SecurityProtocol.cs" />
     <Compile Include="$(CommonPath)System\NotImplemented.cs"
              Link="Common\System\NotImplemented.cs" />
-    <Compile Include="$(CommonPath)\System\Net\StreamBuffer.cs" 
-             Link="Common\System\Net\StreamBuffer.cs" />
-    <Compile Include="$(CommonPath)\System\Net\MultiArrayBuffer.cs" 
-             Link="Common\System\Net\MultiArrayBuffer.cs" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetPlatformIdentifier)' == 'windows'">

src/libraries/System.Net.Requests/src/System/Net/HttpWebRequest.cs

@@ -63,7 +63,7 @@ public class HttpWebRequest : WebRequest, ISerializable
         private bool _hostHasPort;
         private Uri? _hostUri;
 
-        private RequestStream? _requestStream;
+        private Stream? _requestStream;
         private TaskCompletionSource<Stream>? _requestStreamOperation;
         private TaskCompletionSource<WebResponse>? _responseOperation;
         private AsyncCallback? _requestStreamCallback;
@@ -1070,22 +1070,24 @@ private Task<Stream> InternalGetRequestStream()
                 throw new InvalidOperationException(SR.net_reqsubmitted);
             }
 
-            // Create stream buffer for transferring data from RequestStream to the StreamContent.
-            StreamBuffer streamBuffer = new StreamBuffer(maxBufferSize: AllowWriteStreamBuffering ? int.MaxValue : StreamBuffer.DefaultMaxBufferSize);
-
             // If we aren't buffering we need to open the connection right away.
             // Because we need to send the data as soon as possible when it's available from the RequestStream.
             // Making this allows us to keep the sync send request path for buffering cases.
             if (AllowWriteStreamBuffering is false)
             {
                 // We're calling SendRequest with async, because we need to open the connection and send the request
                 // Otherwise, sync path will block the current thread until the request is sent.
-                _sendRequestTask = SendRequest(true, new RequestStreamContent(new HttpClientContentStream(streamBuffer)));
+                TaskCompletionSource<Stream> getStreamTcs = new();
+                TaskCompletionSource completeTcs = new();
+                _sendRequestTask = SendRequest(async: true, new RequestStreamContent(getStreamTcs, completeTcs));
+                _requestStream = new RequestStream(getStreamTcs.Task.GetAwaiter().GetResult(), completeTcs);
+            }
+            else
+            {
+                _requestStream = new RequestBufferingStream();
             }
 
-            _requestStream = new RequestStream(streamBuffer);
-
-            return Task.FromResult((Stream)_requestStream);
+            return Task.FromResult(_requestStream);
         }
 
         public Stream EndGetRequestStream(IAsyncResult asyncResult, out TransportContext? context)
@@ -1155,12 +1157,6 @@ private Task<HttpResponseMessage> SendRequest(bool async, HttpContent? content =
 
             if (content is not null)
             {
-                // Calculate Content-Length if we're buffering.
-                if (AllowWriteStreamBuffering && _requestStream is not null)
-                {
-                    content.Headers.ContentLength = _requestStream.GetBuffer().ReadBytesAvailable;
-                }
-
                 _sendRequestMessage.Content = content;
             }
 
@@ -1218,13 +1214,20 @@ private Task<HttpResponseMessage> SendRequest(bool async, HttpContent? content =
 
         private async Task<WebResponse> HandleResponse(bool async)
         {
-            // If user code used requestStream and didn't dispose it (end write on StreamBuffer)
-            // We're ending it here.
-            _requestStream?.EndWriteOnStreamBuffer();
+            // If user code used requestStream and didn't dispose it
+            // We're completing it here.
+            if (_requestStream is RequestStream requestStream)
+            {
+                requestStream.Complete();
+            }
 
-            _sendRequestTask ??= _requestStream is not null ?
-                SendRequest(async, new StreamContent(new HttpClientContentStream(_requestStream.GetBuffer()))) :
-                SendRequest(async);
+            if (_sendRequestTask is null && _requestStream is RequestBufferingStream requestBufferingStream)
+            {
+                ArraySegment<byte> buffer = requestBufferingStream.GetBuffer();
+                _sendRequestTask = SendRequest(async, new ByteArrayContent(buffer.Array!, buffer.Offset, buffer.Count));
+            }
+
+            _sendRequestTask ??= SendRequest(async);
 
             try
             {
@@ -1246,6 +1249,10 @@ private async Task<WebResponse> HandleResponse(bool async)
             finally
             {
                 _sendRequestMessage?.Dispose();
+                if (_requestStream is RequestBufferingStream bufferStream)
+                {
+                    bufferStream.GetMemoryStream().Dispose();
+                }
 
                 if (_disposeRequired)
                 {

src/libraries/System.Net.Requests/src/System/Net/RequestBufferingStream.cs

@@ -0,0 +1,158 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Net
+{
+    // Cache the request stream into a MemoryStream.
+    internal sealed class RequestBufferingStream : Stream
+    {
+        private bool _disposed;
+        private readonly MemoryStream _buffer = new MemoryStream();
+
+        public RequestBufferingStream()
+        {
+        }
+
+        public override bool CanRead
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool CanSeek
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        public override bool CanWrite
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override void Flush()
+        {
+            ThrowIfDisposed();
+            // Nothing to do.
+        }
+
+        public override Task FlushAsync(CancellationToken cancellationToken)
+        {
+            ThrowIfDisposed();
+            // Nothing to do.
+            return cancellationToken.IsCancellationRequested ?
+                Task.FromCanceled(cancellationToken) :
+                Task.CompletedTask;
+        }
+
+        public override long Length
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public override long Position
+        {
+            get
+            {
+                throw new NotSupportedException();
+            }
+            set
+            {
+                throw new NotSupportedException();
+            }
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            ThrowIfDisposed();
+            ValidateBufferArguments(buffer, offset, count);
+            _buffer.Write(buffer, offset, count);
+        }
+
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            ThrowIfDisposed();
+            ValidateBufferArguments(buffer, offset, count);
+            return _buffer.WriteAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            ThrowIfDisposed();
+            return _buffer.WriteAsync(buffer, cancellationToken);
+        }
+
+        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback? asyncCallback, object? asyncState)
+        {
+            ThrowIfDisposed();
+            ValidateBufferArguments(buffer, offset, count);
+            return _buffer.BeginWrite(buffer, offset, count, asyncCallback, asyncState);
+        }
+
+        public override void EndWrite(IAsyncResult asyncResult)
+        {
+            ThrowIfDisposed();
+            _buffer.EndWrite(asyncResult);
+        }
+
+        public ArraySegment<byte> GetBuffer()
+        {
+            ArraySegment<byte> bytes;
+
+            bool success = _buffer.TryGetBuffer(out bytes);
+            Debug.Assert(success); // Buffer should always be visible since default MemoryStream constructor was used.
+
+            return bytes;
+        }
+
+        // We need this to dispose the MemoryStream.
+        public MemoryStream GetMemoryStream()
+        {
+            return _buffer;
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && !_disposed)
+            {
+                _disposed = true;
+            }
+            base.Dispose(disposing);
+        }
+
+        private void ThrowIfDisposed()
+        {
+            ObjectDisposedException.ThrowIf(_disposed, this);
+        }
+    }
+}