Modify StreamContent to use default CopyToAsync buffer size when no size is provided (#27176)

* Add a tentative fix

* Minor fixes.

* Remove unused default value.

* Re-order error checks for compatibility reasons.

* Add a test to pin exception behavior when both parameters are incorrect.

Author: rmkerr

src/System.Net.Http/src/System/Net/Http/StreamContent.cs

@@ -11,16 +11,20 @@ namespace System.Net.Http
 {
     public class StreamContent : HttpContent
     {
-        private const int DefaultBufferSize = 4096;
-
         private Stream _content;
         private int _bufferSize;
         private bool _contentConsumed;
         private long _start;
 
         public StreamContent(Stream content)
-            : this(content, DefaultBufferSize)
         {
+            if (content == null)
+            {
+                throw new ArgumentNullException(nameof(content));
+            }
+
+            // Indicate that we should use default buffer size by setting size to 0.
+            InitializeContent(content, 0);
         }
 
         public StreamContent(Stream content, int bufferSize)
@@ -34,6 +38,11 @@ public StreamContent(Stream content, int bufferSize)
                 throw new ArgumentOutOfRangeException(nameof(bufferSize));
             }
 
+            InitializeContent(content, bufferSize);
+        }
+
+        private void InitializeContent(Stream content, int bufferSize)
+        {
             _content = content;
             _bufferSize = bufferSize;
             if (content.CanSeek)

src/System.Net.Http/src/System/Net/Http/StreamToStreamCopy.cs

@@ -19,18 +19,20 @@ internal static class StreamToStreamCopy
         /// <summary>Copies the source stream from its current position to the destination stream at its current position.</summary>
         /// <param name="source">The source stream from which to copy.</param>
         /// <param name="destination">The destination stream to which to copy.</param>
-        /// <param name="bufferSize">The size of the buffer to allocate if one needs to be allocated.</param>
+        /// <param name="bufferSize">The size of the buffer to allocate if one needs to be allocated. If zero, use the default buffer size.</param>
         /// <param name="disposeSource">Whether to dispose of the source stream after the copy has finished successfully.</param>
         /// <param name="cancellationToken">CancellationToken used to cancel the copy operation.</param>
         public static Task CopyAsync(Stream source, Stream destination, int bufferSize, bool disposeSource, CancellationToken cancellationToken = default(CancellationToken))
         {
             Debug.Assert(source != null);
             Debug.Assert(destination != null);
-            Debug.Assert(bufferSize > 0);
+            Debug.Assert(bufferSize >= 0);
 
             try
             {
-                Task copyTask = source.CopyToAsync(destination, bufferSize, cancellationToken);
+                Task copyTask = bufferSize == 0 ?
+                    source.CopyToAsync(destination, cancellationToken) :
+                    source.CopyToAsync(destination, bufferSize, cancellationToken);
                 return disposeSource ?
                     DisposeSourceWhenCompleteAsync(copyTask, source) :
                     copyTask;

src/System.Net.Http/tests/FunctionalTests/StreamContentTest.cs

@@ -32,6 +32,12 @@ public void Ctor_ZeroBufferSize_ThrowsArgumentOutOfRangeException()
             Assert.Throws<ArgumentOutOfRangeException>(() => new StreamContent(new MemoryStream(), 0));
         }
 
+        [Fact]
+        public void Ctor_NullStreamAndZeroBufferSize_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => new StreamContent(null, 0));
+        }
+
         [Fact]
         public void ContentLength_SetStreamSupportingSeeking_StreamLengthMatchesHeaderValue()
         {