Rename new Stream.Read/Write{Async} Span/Memory arguments to buffer (#28429)

Anipik · stephentoub · commit 61fdee4e0bba · 2018-03-23T21:35:40.000-04:00
* updated implementation

* http content fixed
diff --git a/src/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliStream.Decompress.cs b/src/System.IO.Compression.Brotli/src/System/IO/Compression/dec/BrotliStream.Decompress.cs
@@ -18,7 +18,7 @@ public override int Read(byte[] buffer, int offset, int count)
             return Read(new Span<byte>(buffer, offset, count));
         }
 
-        public override int Read(Span<byte> destination)
+        public override int Read(Span<byte> buffer)
         {
             if (_mode != CompressionMode.Decompress)
                 throw new InvalidOperationException(SR.BrotliStream_Compress_UnsupportedOperation);
@@ -27,7 +27,7 @@ public override int Read(Span<byte> destination)
             Span<byte> source = Span<byte>.Empty;
             OperationStatus lastResult = OperationStatus.DestinationTooSmall;
             // We want to continue calling Decompress until we're either out of space for output or until Decompress indicates it is finished.
-            while (destination.Length > 0 && lastResult != OperationStatus.Done)
+            while (buffer.Length > 0 && lastResult != OperationStatus.Done)
             {
                 int bytesConsumed = 0;
                 int bytesWritten = 0;
@@ -53,15 +53,15 @@ public override int Read(Span<byte> destination)
                     source = new Span<byte>(_buffer, 0, readBytes);
                 }
 
-                lastResult = _decoder.Decompress(source, destination, out bytesConsumed, out bytesWritten);
+                lastResult = _decoder.Decompress(source, buffer, out bytesConsumed, out bytesWritten);
                 if (lastResult == OperationStatus.InvalidData)
                     throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);
                 if (bytesConsumed > 0)
                     source = source.Slice(bytesConsumed);
                 if (bytesWritten > 0)
                 {
                     totalWritten += bytesWritten;
-                    destination = destination.Slice(bytesWritten);
+                    buffer = buffer.Slice(bytesWritten);
                 }
             }
 
@@ -80,7 +80,7 @@ public override Task<int> ReadAsync(byte[] array, int offset, int count, Cancell
             return ReadAsync(new Memory<byte>(array, offset, count), cancellationToken).AsTask();
         }
 
-        public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (_mode != CompressionMode.Decompress)
                 throw new InvalidOperationException(SR.BrotliStream_Compress_UnsupportedOperation);
@@ -91,10 +91,10 @@ public override Task<int> ReadAsync(byte[] array, int offset, int count, Cancell
             {
                 return new ValueTask<int>(Task.FromCanceled<int>(cancellationToken));
             }
-             return FinishReadAsyncMemory(destination, cancellationToken);
+             return FinishReadAsyncMemory(buffer, cancellationToken);
         }
 
-        private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> destination, CancellationToken cancellationToken)
+        private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> buffer, CancellationToken cancellationToken)
         {
             AsyncOperationStarting();
             try
@@ -103,7 +103,7 @@ private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> destination, Can
                 Memory<byte> source = Memory<byte>.Empty;
                 OperationStatus lastResult = OperationStatus.DestinationTooSmall;
                 // We want to continue calling Decompress until we're either out of space for output or until Decompress indicates it is finished.
-                while (destination.Length > 0 && lastResult != OperationStatus.Done)
+                while (buffer.Length > 0 && lastResult != OperationStatus.Done)
                 {
 
                     int bytesConsumed = 0;
@@ -131,15 +131,15 @@ private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> destination, Can
                     }
 
                     cancellationToken.ThrowIfCancellationRequested();
-                    lastResult = _decoder.Decompress(source, destination, out bytesConsumed, out bytesWritten);
+                    lastResult = _decoder.Decompress(source, buffer, out bytesConsumed, out bytesWritten);
                     if (lastResult == OperationStatus.InvalidData)
                         throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);
                     if (bytesConsumed > 0)
                         source = source.Slice(bytesConsumed);
                     if (bytesWritten > 0)
                     {
                         totalWritten += bytesWritten;
-                        destination = destination.Slice(bytesWritten);
+                        buffer = buffer.Slice(bytesWritten);
                     }
                 }
 
diff --git a/src/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs b/src/System.IO.Compression.Brotli/src/System/IO/Compression/enc/BrotliStream.Compress.cs
@@ -24,12 +24,12 @@ public override void Write(byte[] buffer, int offset, int count)
             WriteCore(new ReadOnlySpan<byte>(buffer, offset, count));
         }
 
-        public override void Write(ReadOnlySpan<byte> source)
+        public override void Write(ReadOnlySpan<byte> buffer)
         {
-            WriteCore(source);
+            WriteCore(buffer);
         }
 
-        internal void WriteCore(ReadOnlySpan<byte> source, bool isFinalBlock = false)
+        internal void WriteCore(ReadOnlySpan<byte> buffer, bool isFinalBlock = false)
         {
             if (_mode != CompressionMode.Compress)
                 throw new InvalidOperationException(SR.BrotliStream_Decompress_UnsupportedOperation);
@@ -41,13 +41,13 @@ internal void WriteCore(ReadOnlySpan<byte> source, bool isFinalBlock = false)
             {
                 int bytesConsumed = 0;
                 int bytesWritten = 0;
-                lastResult = _encoder.Compress(source, output, out bytesConsumed, out bytesWritten, isFinalBlock);
+                lastResult = _encoder.Compress(buffer, output, out bytesConsumed, out bytesWritten, isFinalBlock);
                 if (lastResult == OperationStatus.InvalidData)
                     throw new InvalidOperationException(SR.BrotliStream_Compress_InvalidData);
                 if (bytesWritten > 0)
                     _stream.Write(output.Slice(0, bytesWritten));
                 if (bytesConsumed > 0)
-                    source = source.Slice(bytesConsumed);
+                    buffer = buffer.Slice(bytesConsumed);
             }
         }
 
@@ -63,7 +63,7 @@ public override Task WriteAsync(byte[] array, int offset, int count, Cancellatio
             return WriteAsync(new ReadOnlyMemory<byte>(array, offset, count), cancellationToken).AsTask();
         }
 
-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
             if (_mode != CompressionMode.Compress)
                 throw new InvalidOperationException(SR.BrotliStream_Decompress_UnsupportedOperation);
@@ -72,10 +72,10 @@ public override Task WriteAsync(byte[] array, int offset, int count, Cancellatio
 
             return new ValueTask(cancellationToken.IsCancellationRequested ?
                 Task.FromCanceled<int>(cancellationToken) :
-                WriteAsyncMemoryCore(source, cancellationToken));
+                WriteAsyncMemoryCore(buffer, cancellationToken));
         }
 
-        private async Task WriteAsyncMemoryCore(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
+        private async Task WriteAsyncMemoryCore(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
         {
             AsyncOperationStarting();
             try
@@ -86,11 +86,11 @@ private async Task WriteAsyncMemoryCore(ReadOnlyMemory<byte> source, Cancellatio
                     Memory<byte> output = new Memory<byte>(_buffer);
                     int bytesConsumed = 0;
                     int bytesWritten = 0;
-                    lastResult = _encoder.Compress(source, output, out bytesConsumed, out bytesWritten, isFinalBlock: false);
+                    lastResult = _encoder.Compress(buffer, output, out bytesConsumed, out bytesWritten, isFinalBlock: false);
                     if (lastResult == OperationStatus.InvalidData)
                         throw new InvalidOperationException(SR.BrotliStream_Compress_InvalidData);
                     if (bytesConsumed > 0)
-                        source = source.Slice(bytesConsumed);
+                        buffer = buffer.Slice(bytesConsumed);
                     if (bytesWritten > 0)
                         await _stream.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, bytesWritten), cancellationToken).ConfigureAwait(false);
                 }
diff --git a/src/System.IO.Compression/src/System/IO/Compression/PositionPreservingWriteOnlyStreamWrapper.netcoreapp.cs b/src/System.IO.Compression/src/System/IO/Compression/PositionPreservingWriteOnlyStreamWrapper.netcoreapp.cs
@@ -9,16 +9,16 @@ namespace System.IO.Compression
 {
     internal sealed partial class PositionPreservingWriteOnlyStreamWrapper : Stream
     {
-        public override void Write(ReadOnlySpan<byte> source)
+        public override void Write(ReadOnlySpan<byte> buffer)
         {
-            _position += source.Length;
-            _stream.Write(source);
+            _position += buffer.Length;
+            _stream.Write(buffer);
         }
 
-        public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))
         {
-            _position += source.Length;
-            return _stream.WriteAsync(source, cancellationToken);
+            _position += buffer.Length;
+            return _stream.WriteAsync(buffer, cancellationToken);
         }
     }
 }
diff --git a/src/System.Net.Http/src/System/Net/Http/CurlHandler/CurlHandler.CurlResponseMessage.cs b/src/System.Net.Http/src/System/Net/Http/CurlHandler/CurlHandler.CurlResponseMessage.cs
@@ -253,11 +253,11 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
                 return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
             }
 
-            public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default)
+            public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
             {
                 CheckDisposed();
 
-                EventSourceTrace("Buffer: {0}", destination.Length);
+                EventSourceTrace("Buffer: {0}", buffer.Length);
 
                 // Check for cancellation
                 if (cancellationToken.IsCancellationRequested)
@@ -290,16 +290,16 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT
 
                     // Quick check for if no data was actually requested.  We do this after the check
                     // for errors so that we can still fail the read and transfer the exception if we should.
-                    if (destination.Length == 0)
+                    if (buffer.Length == 0)
                     {
                         return new ValueTask<int>(0);
                     }
 
                     // If there's any data left over from a previous call, grab as much as we can.
                     if (_remainingDataCount > 0)
                     {
-                        int bytesToCopy = Math.Min(destination.Length, _remainingDataCount);
-                        new Span<byte>(_remainingData, _remainingDataOffset, bytesToCopy).CopyTo(destination.Span);
+                        int bytesToCopy = Math.Min(buffer.Length, _remainingDataCount);
+                        new Span<byte>(_remainingData, _remainingDataOffset, bytesToCopy).CopyTo(buffer.Span);
 
                         _remainingDataOffset += bytesToCopy;
                         _remainingDataCount -= bytesToCopy;
@@ -332,7 +332,7 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT
                         // the cancellation token.  Dispose on the registration won't return until the action
                         // associated with the registration has completed, but if that action is currently
                         // executing and is blocked on the lock that's held while calling Dispose... deadlock.
-                        var crs = new CancelableReadState(destination, this, cancellationToken);
+                        var crs = new CancelableReadState(buffer, this, cancellationToken);
                         crs._registration = cancellationToken.Register(s1 =>
                         {
                             ((CancelableReadState)s1)._stream.EventSourceTrace("Cancellation invoked. Queueing work item to cancel read state");
@@ -356,7 +356,7 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT
                     else
                     {
                         // The token isn't cancelable.  Just create a normal read state.
-                        _pendingReadRequest = new ReadState(destination);
+                        _pendingReadRequest = new ReadState(buffer);
                     }
 
                     _easy._associatedMultiAgent.RequestUnpause(_easy);
diff --git a/src/System.Net.Http/src/System/Net/Http/HttpContent.cs b/src/System.Net.Http/src/System/Net/Http/HttpContent.cs
@@ -731,10 +731,10 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati
                 return base.WriteAsync(buffer, offset, count, cancellationToken);
             }
 
-            public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
+            public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)
             {
-                CheckSize(source.Length);
-                return base.WriteAsync(source, cancellationToken);
+                CheckSize(buffer.Length);
+                return base.WriteAsync(buffer, cancellationToken);
             }
 
             public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
@@ -869,11 +869,11 @@ public override void Write(byte[] buffer, int offset, int count)
                 _length += count;
             }
 
-            public override void Write(ReadOnlySpan<byte> source)
+            public override void Write(ReadOnlySpan<byte> buffer)
             {
-                EnsureCapacity(_length + source.Length);
-                source.CopyTo(new Span<byte>(_buffer, _length, source.Length));
-                _length += source.Length;
+                EnsureCapacity(_length + buffer.Length);
+                buffer.CopyTo(new Span<byte>(_buffer, _length, buffer.Length));
+                _length += buffer.Length;
             }
 
             public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
@@ -882,9 +882,9 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati
                 return Task.CompletedTask;
             }
 
-            public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default)
+            public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
             {
-                Write(source.Span);
+                Write(buffer.Span);
                 return default;
             }
 
diff --git a/src/System.Net.Http/src/System/Net/Http/MultipartContent.cs b/src/System.Net.Http/src/System/Net/Http/MultipartContent.cs
@@ -417,9 +417,9 @@ public override int Read(byte[] buffer, int offset, int count)
                 }
             }
 
-            public override int Read(Span<byte> destination)
+            public override int Read(Span<byte> buffer)
             {
-                if (destination.Length == 0)
+                if (buffer.Length == 0)
                 {
                     return 0;
                 }
@@ -428,7 +428,7 @@ public override int Read(Span<byte> destination)
                 {
                     if (_current != null)
                     {
-                        int bytesRead = _current.Read(destination);
+                        int bytesRead = _current.Read(buffer);
                         if (bytesRead != 0)
                         {
                             _position += bytesRead;
@@ -453,18 +453,18 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel
                 return ReadAsyncPrivate(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
             }
 
-            public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default) =>
-                ReadAsyncPrivate(destination, cancellationToken);
+            public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) =>
+                ReadAsyncPrivate(buffer, cancellationToken);
 
             public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) =>
                 TaskToApm.Begin(ReadAsync(array, offset, count, CancellationToken.None), asyncCallback, asyncState);
 
             public override int EndRead(IAsyncResult asyncResult) =>
                 TaskToApm.End<int>(asyncResult);
 
-            public async ValueTask<int> ReadAsyncPrivate(Memory<byte> destination, CancellationToken cancellationToken)
+            public async ValueTask<int> ReadAsyncPrivate(Memory<byte> buffer, CancellationToken cancellationToken)
             {
-                if (destination.Length == 0)
+                if (buffer.Length == 0)
                 {
                     return 0;
                 }
@@ -473,7 +473,7 @@ public async ValueTask<int> ReadAsyncPrivate(Memory<byte> destination, Cancellat
                 {
                     if (_current != null)
                     {
-                        int bytesRead = await _current.ReadAsync(destination, cancellationToken).ConfigureAwait(false);
+                        int bytesRead = await _current.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
                         if (bytesRead != 0)
                         {
                             _position += bytesRead;
@@ -581,9 +581,9 @@ private static void ValidateReadArgs(byte[] buffer, int offset, int count)
             public override void Flush() { }
             public override void SetLength(long value) { throw new NotSupportedException(); }
             public override void Write(byte[] buffer, int offset, int count) { throw new NotSupportedException(); }
-            public override void Write(ReadOnlySpan<byte> source) { throw new NotSupportedException(); }
+            public override void Write(ReadOnlySpan<byte> buffer) { throw new NotSupportedException(); }
             public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { throw new NotSupportedException(); }
-            public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default) { throw new NotSupportedException(); }
+            public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) { throw new NotSupportedException(); }
         }
         #endregion Serialization
     }
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ChunkedEncodingWriteStream.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ChunkedEncodingWriteStream.cs
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ContentLengthWriteStream.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ContentLengthWriteStream.cs
diff --git a/src/System.Net.Http/src/System/Net/Http/StreamContent.cs b/src/System.Net.Http/src/System/Net/Http/StreamContent.cs

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public override int Read(byte[] buffer, int offset, int count)`
`18`	`18`	`return Read(new Span<byte>(buffer, offset, count));`
`19`	`19`	`}`
`20`	`20`
`21`		`- public override int Read(Span<byte> destination)`
	`21`	`+ public override int Read(Span<byte> buffer)`
`22`	`22`	`{`
`23`	`23`	`if (_mode != CompressionMode.Decompress)`
`24`	`24`	`throw new InvalidOperationException(SR.BrotliStream_Compress_UnsupportedOperation);`
`@@ -27,7 +27,7 @@ public override int Read(Span<byte> destination)`
`27`	`27`	`Span<byte> source = Span<byte>.Empty;`
`28`	`28`	`OperationStatus lastResult = OperationStatus.DestinationTooSmall;`
`29`	`29`	`// We want to continue calling Decompress until we're either out of space for output or until Decompress indicates it is finished.`
`30`		`- while (destination.Length > 0 && lastResult != OperationStatus.Done)`
	`30`	`+ while (buffer.Length > 0 && lastResult != OperationStatus.Done)`
`31`	`31`	`{`
`32`	`32`	`int bytesConsumed = 0;`
`33`	`33`	`int bytesWritten = 0;`
`@@ -53,15 +53,15 @@ public override int Read(Span<byte> destination)`
`53`	`53`	`source = new Span<byte>(_buffer, 0, readBytes);`
`54`	`54`	`}`
`55`	`55`
`56`		`- lastResult = _decoder.Decompress(source, destination, out bytesConsumed, out bytesWritten);`
	`56`	`+ lastResult = _decoder.Decompress(source, buffer, out bytesConsumed, out bytesWritten);`
`57`	`57`	`if (lastResult == OperationStatus.InvalidData)`
`58`	`58`	`throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);`
`59`	`59`	`if (bytesConsumed > 0)`
`60`	`60`	`source = source.Slice(bytesConsumed);`
`61`	`61`	`if (bytesWritten > 0)`
`62`	`62`	`{`
`63`	`63`	`totalWritten += bytesWritten;`
`64`		`- destination = destination.Slice(bytesWritten);`
	`64`	`+ buffer = buffer.Slice(bytesWritten);`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`@@ -80,7 +80,7 @@ public override Task<int> ReadAsync(byte[] array, int offset, int count, Cancell`
`80`	`80`	`return ReadAsync(new Memory<byte>(array, offset, count), cancellationToken).AsTask();`
`81`	`81`	`}`
`82`	`82`
`83`		`- public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default(CancellationToken))`
	`83`	`+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`84`	`84`	`{`
`85`	`85`	`if (_mode != CompressionMode.Decompress)`
`86`	`86`	`throw new InvalidOperationException(SR.BrotliStream_Compress_UnsupportedOperation);`
`@@ -91,10 +91,10 @@ public override Task<int> ReadAsync(byte[] array, int offset, int count, Cancell`
`91`	`91`	`{`
`92`	`92`	`return new ValueTask<int>(Task.FromCanceled<int>(cancellationToken));`
`93`	`93`	`}`
`94`		`- return FinishReadAsyncMemory(destination, cancellationToken);`
	`94`	`+ return FinishReadAsyncMemory(buffer, cancellationToken);`
`95`	`95`	`}`
`96`	`96`
`97`		`- private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> destination, CancellationToken cancellationToken)`
	`97`	`+ private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> buffer, CancellationToken cancellationToken)`
`98`	`98`	`{`
`99`	`99`	`AsyncOperationStarting();`
`100`	`100`	`try`
`@@ -103,7 +103,7 @@ private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> destination, Can`
`103`	`103`	`Memory<byte> source = Memory<byte>.Empty;`
`104`	`104`	`OperationStatus lastResult = OperationStatus.DestinationTooSmall;`
`105`	`105`	`// We want to continue calling Decompress until we're either out of space for output or until Decompress indicates it is finished.`
`106`		`- while (destination.Length > 0 && lastResult != OperationStatus.Done)`
	`106`	`+ while (buffer.Length > 0 && lastResult != OperationStatus.Done)`
`107`	`107`	`{`
`108`	`108`
`109`	`109`	`int bytesConsumed = 0;`
`@@ -131,15 +131,15 @@ private async ValueTask<int> FinishReadAsyncMemory(Memory<byte> destination, Can`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`cancellationToken.ThrowIfCancellationRequested();`
`134`		`- lastResult = _decoder.Decompress(source, destination, out bytesConsumed, out bytesWritten);`
	`134`	`+ lastResult = _decoder.Decompress(source, buffer, out bytesConsumed, out bytesWritten);`
`135`	`135`	`if (lastResult == OperationStatus.InvalidData)`
`136`	`136`	`throw new InvalidOperationException(SR.BrotliStream_Decompress_InvalidData);`
`137`	`137`	`if (bytesConsumed > 0)`
`138`	`138`	`source = source.Slice(bytesConsumed);`
`139`	`139`	`if (bytesWritten > 0)`
`140`	`140`	`{`
`141`	`141`	`totalWritten += bytesWritten;`
`142`		`- destination = destination.Slice(bytesWritten);`
	`142`	`+ buffer = buffer.Slice(bytesWritten);`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`
Original file line number	Diff line number	Diff line change
`@@ -24,12 +24,12 @@ public override void Write(byte[] buffer, int offset, int count)`
`24`	`24`	`WriteCore(new ReadOnlySpan<byte>(buffer, offset, count));`
`25`	`25`	`}`
`26`	`26`
`27`		`- public override void Write(ReadOnlySpan<byte> source)`
	`27`	`+ public override void Write(ReadOnlySpan<byte> buffer)`
`28`	`28`	`{`
`29`		`- WriteCore(source);`
	`29`	`+ WriteCore(buffer);`
`30`	`30`	`}`
`31`	`31`
`32`		`- internal void WriteCore(ReadOnlySpan<byte> source, bool isFinalBlock = false)`
	`32`	`+ internal void WriteCore(ReadOnlySpan<byte> buffer, bool isFinalBlock = false)`
`33`	`33`	`{`
`34`	`34`	`if (_mode != CompressionMode.Compress)`
`35`	`35`	`throw new InvalidOperationException(SR.BrotliStream_Decompress_UnsupportedOperation);`
`@@ -41,13 +41,13 @@ internal void WriteCore(ReadOnlySpan<byte> source, bool isFinalBlock = false)`
`41`	`41`	`{`
`42`	`42`	`int bytesConsumed = 0;`
`43`	`43`	`int bytesWritten = 0;`
`44`		`- lastResult = _encoder.Compress(source, output, out bytesConsumed, out bytesWritten, isFinalBlock);`
	`44`	`+ lastResult = _encoder.Compress(buffer, output, out bytesConsumed, out bytesWritten, isFinalBlock);`
`45`	`45`	`if (lastResult == OperationStatus.InvalidData)`
`46`	`46`	`throw new InvalidOperationException(SR.BrotliStream_Compress_InvalidData);`
`47`	`47`	`if (bytesWritten > 0)`
`48`	`48`	`_stream.Write(output.Slice(0, bytesWritten));`
`49`	`49`	`if (bytesConsumed > 0)`
`50`		`- source = source.Slice(bytesConsumed);`
	`50`	`+ buffer = buffer.Slice(bytesConsumed);`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`@@ -63,7 +63,7 @@ public override Task WriteAsync(byte[] array, int offset, int count, Cancellatio`
`63`	`63`	`return WriteAsync(new ReadOnlyMemory<byte>(array, offset, count), cancellationToken).AsTask();`
`64`	`64`	`}`
`65`	`65`
`66`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))`
	`66`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`67`	`67`	`{`
`68`	`68`	`if (_mode != CompressionMode.Compress)`
`69`	`69`	`throw new InvalidOperationException(SR.BrotliStream_Decompress_UnsupportedOperation);`
`@@ -72,10 +72,10 @@ public override Task WriteAsync(byte[] array, int offset, int count, Cancellatio`
`72`	`72`
`73`	`73`	`return new ValueTask(cancellationToken.IsCancellationRequested ?`
`74`	`74`	`Task.FromCanceled<int>(cancellationToken) :`
`75`		`- WriteAsyncMemoryCore(source, cancellationToken));`
	`75`	`+ WriteAsyncMemoryCore(buffer, cancellationToken));`
`76`	`76`	`}`
`77`	`77`
`78`		`- private async Task WriteAsyncMemoryCore(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)`
	`78`	`+ private async Task WriteAsyncMemoryCore(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)`
`79`	`79`	`{`
`80`	`80`	`AsyncOperationStarting();`
`81`	`81`	`try`
`@@ -86,11 +86,11 @@ private async Task WriteAsyncMemoryCore(ReadOnlyMemory<byte> source, Cancellatio`
`86`	`86`	`Memory<byte> output = new Memory<byte>(_buffer);`
`87`	`87`	`int bytesConsumed = 0;`
`88`	`88`	`int bytesWritten = 0;`
`89`		`- lastResult = _encoder.Compress(source, output, out bytesConsumed, out bytesWritten, isFinalBlock: false);`
	`89`	`+ lastResult = _encoder.Compress(buffer, output, out bytesConsumed, out bytesWritten, isFinalBlock: false);`
`90`	`90`	`if (lastResult == OperationStatus.InvalidData)`
`91`	`91`	`throw new InvalidOperationException(SR.BrotliStream_Compress_InvalidData);`
`92`	`92`	`if (bytesConsumed > 0)`
`93`		`- source = source.Slice(bytesConsumed);`
	`93`	`+ buffer = buffer.Slice(bytesConsumed);`
`94`	`94`	`if (bytesWritten > 0)`
`95`	`95`	`await _stream.WriteAsync(new ReadOnlyMemory<byte>(_buffer, 0, bytesWritten), cancellationToken).ConfigureAwait(false);`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,16 +9,16 @@ namespace System.IO.Compression`
`9`	`9`	`{`
`10`	`10`	`internal sealed partial class PositionPreservingWriteOnlyStreamWrapper : Stream`
`11`	`11`	`{`
`12`		`- public override void Write(ReadOnlySpan<byte> source)`
	`12`	`+ public override void Write(ReadOnlySpan<byte> buffer)`
`13`	`13`	`{`
`14`		`- _position += source.Length;`
`15`		`- _stream.Write(source);`
	`14`	`+ _position += buffer.Length;`
	`15`	`+ _stream.Write(buffer);`
`16`	`16`	`}`
`17`	`17`
`18`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default(CancellationToken))`
	`18`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default(CancellationToken))`
`19`	`19`	`{`
`20`		`- _position += source.Length;`
`21`		`- return _stream.WriteAsync(source, cancellationToken);`
	`20`	`+ _position += buffer.Length;`
	`21`	`+ return _stream.WriteAsync(buffer, cancellationToken);`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -253,11 +253,11 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel`
`253`	`253`	`return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();`
`254`	`254`	`}`
`255`	`255`
`256`		`- public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default)`
	`256`	`+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)`
`257`	`257`	`{`
`258`	`258`	`CheckDisposed();`
`259`	`259`
`260`		`- EventSourceTrace("Buffer: {0}", destination.Length);`
	`260`	`+ EventSourceTrace("Buffer: {0}", buffer.Length);`
`261`	`261`
`262`	`262`	`// Check for cancellation`
`263`	`263`	`if (cancellationToken.IsCancellationRequested)`
`@@ -290,16 +290,16 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT`
`290`	`290`
`291`	`291`	`// Quick check for if no data was actually requested. We do this after the check`
`292`	`292`	`// for errors so that we can still fail the read and transfer the exception if we should.`
`293`		`- if (destination.Length == 0)`
	`293`	`+ if (buffer.Length == 0)`
`294`	`294`	`{`
`295`	`295`	`return new ValueTask<int>(0);`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`// If there's any data left over from a previous call, grab as much as we can.`
`299`	`299`	`if (_remainingDataCount > 0)`
`300`	`300`	`{`
`301`		`- int bytesToCopy = Math.Min(destination.Length, _remainingDataCount);`
`302`		`- new Span<byte>(_remainingData, _remainingDataOffset, bytesToCopy).CopyTo(destination.Span);`
	`301`	`+ int bytesToCopy = Math.Min(buffer.Length, _remainingDataCount);`
	`302`	`+ new Span<byte>(_remainingData, _remainingDataOffset, bytesToCopy).CopyTo(buffer.Span);`
`303`	`303`
`304`	`304`	`_remainingDataOffset += bytesToCopy;`
`305`	`305`	`_remainingDataCount -= bytesToCopy;`
`@@ -332,7 +332,7 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT`
`332`	`332`	`// the cancellation token. Dispose on the registration won't return until the action`
`333`	`333`	`// associated with the registration has completed, but if that action is currently`
`334`	`334`	`// executing and is blocked on the lock that's held while calling Dispose... deadlock.`
`335`		`- var crs = new CancelableReadState(destination, this, cancellationToken);`
	`335`	`+ var crs = new CancelableReadState(buffer, this, cancellationToken);`
`336`	`336`	`crs._registration = cancellationToken.Register(s1 =>`
`337`	`337`	`{`
`338`	`338`	`((CancelableReadState)s1)._stream.EventSourceTrace("Cancellation invoked. Queueing work item to cancel read state");`
`@@ -356,7 +356,7 @@ public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationT`
`356`	`356`	`else`
`357`	`357`	`{`
`358`	`358`	`// The token isn't cancelable. Just create a normal read state.`
`359`		`- _pendingReadRequest = new ReadState(destination);`
	`359`	`+ _pendingReadRequest = new ReadState(buffer);`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`_easy._associatedMultiAgent.RequestUnpause(_easy);`
Original file line number	Diff line number	Diff line change
`@@ -731,10 +731,10 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati`
`731`	`731`	`return base.WriteAsync(buffer, offset, count, cancellationToken);`
`732`	`732`	`}`
`733`	`733`
`734`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)`
	`734`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken)`
`735`	`735`	`{`
`736`		`- CheckSize(source.Length);`
`737`		`- return base.WriteAsync(source, cancellationToken);`
	`736`	`+ CheckSize(buffer.Length);`
	`737`	`+ return base.WriteAsync(buffer, cancellationToken);`
`738`	`738`	`}`
`739`	`739`
`740`	`740`	`public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)`
`@@ -869,11 +869,11 @@ public override void Write(byte[] buffer, int offset, int count)`
`869`	`869`	`_length += count;`
`870`	`870`	`}`
`871`	`871`
`872`		`- public override void Write(ReadOnlySpan<byte> source)`
	`872`	`+ public override void Write(ReadOnlySpan<byte> buffer)`
`873`	`873`	`{`
`874`		`- EnsureCapacity(_length + source.Length);`
`875`		`- source.CopyTo(new Span<byte>(_buffer, _length, source.Length));`
`876`		`- _length += source.Length;`
	`874`	`+ EnsureCapacity(_length + buffer.Length);`
	`875`	`+ buffer.CopyTo(new Span<byte>(_buffer, _length, buffer.Length));`
	`876`	`+ _length += buffer.Length;`
`877`	`877`	`}`
`878`	`878`
`879`	`879`	`public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)`
`@@ -882,9 +882,9 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati`
`882`	`882`	`return Task.CompletedTask;`
`883`	`883`	`}`
`884`	`884`
`885`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default)`
	`885`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)`
`886`	`886`	`{`
`887`		`- Write(source.Span);`
	`887`	`+ Write(buffer.Span);`
`888`	`888`	`return default;`
`889`	`889`	`}`
`890`	`890`
Original file line number	Diff line number	Diff line change
`@@ -417,9 +417,9 @@ public override int Read(byte[] buffer, int offset, int count)`
`417`	`417`	`}`
`418`	`418`	`}`
`419`	`419`
`420`		`- public override int Read(Span<byte> destination)`
	`420`	`+ public override int Read(Span<byte> buffer)`
`421`	`421`	`{`
`422`		`- if (destination.Length == 0)`
	`422`	`+ if (buffer.Length == 0)`
`423`	`423`	`{`
`424`	`424`	`return 0;`
`425`	`425`	`}`
`@@ -428,7 +428,7 @@ public override int Read(Span<byte> destination)`
`428`	`428`	`{`
`429`	`429`	`if (_current != null)`
`430`	`430`	`{`
`431`		`- int bytesRead = _current.Read(destination);`
	`431`	`+ int bytesRead = _current.Read(buffer);`
`432`	`432`	`if (bytesRead != 0)`
`433`	`433`	`{`
`434`	`434`	`_position += bytesRead;`
`@@ -453,18 +453,18 @@ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, Cancel`
`453`	`453`	`return ReadAsyncPrivate(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();`
`454`	`454`	`}`
`455`	`455`
`456`		`- public override ValueTask<int> ReadAsync(Memory<byte> destination, CancellationToken cancellationToken = default) =>`
`457`		`- ReadAsyncPrivate(destination, cancellationToken);`
	`456`	`+ public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) =>`
	`457`	`+ ReadAsyncPrivate(buffer, cancellationToken);`
`458`	`458`
`459`	`459`	`public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) =>`
`460`	`460`	`TaskToApm.Begin(ReadAsync(array, offset, count, CancellationToken.None), asyncCallback, asyncState);`
`461`	`461`
`462`	`462`	`public override int EndRead(IAsyncResult asyncResult) =>`
`463`	`463`	`TaskToApm.End<int>(asyncResult);`
`464`	`464`
`465`		`- public async ValueTask<int> ReadAsyncPrivate(Memory<byte> destination, CancellationToken cancellationToken)`
	`465`	`+ public async ValueTask<int> ReadAsyncPrivate(Memory<byte> buffer, CancellationToken cancellationToken)`
`466`	`466`	`{`
`467`		`- if (destination.Length == 0)`
	`467`	`+ if (buffer.Length == 0)`
`468`	`468`	`{`
`469`	`469`	`return 0;`
`470`	`470`	`}`
`@@ -473,7 +473,7 @@ public async ValueTask<int> ReadAsyncPrivate(Memory<byte> destination, Cancellat`
`473`	`473`	`{`
`474`	`474`	`if (_current != null)`
`475`	`475`	`{`
`476`		`- int bytesRead = await _current.ReadAsync(destination, cancellationToken).ConfigureAwait(false);`
	`476`	`+ int bytesRead = await _current.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);`
`477`	`477`	`if (bytesRead != 0)`
`478`	`478`	`{`
`479`	`479`	`_position += bytesRead;`
`@@ -581,9 +581,9 @@ private static void ValidateReadArgs(byte[] buffer, int offset, int count)`
`581`	`581`	`public override void Flush() { }`
`582`	`582`	`public override void SetLength(long value) { throw new NotSupportedException(); }`
`583`	`583`	`public override void Write(byte[] buffer, int offset, int count) { throw new NotSupportedException(); }`
`584`		`- public override void Write(ReadOnlySpan<byte> source) { throw new NotSupportedException(); }`
	`584`	`+ public override void Write(ReadOnlySpan<byte> buffer) { throw new NotSupportedException(); }`
`585`	`585`	`public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { throw new NotSupportedException(); }`
`586`		`- public override ValueTask WriteAsync(ReadOnlyMemory<byte> source, CancellationToken cancellationToken = default) { throw new NotSupportedException(); }`
	`586`	`+ public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) { throw new NotSupportedException(); }`
`587`	`587`	`}`
`588`	`588`	`#endregion Serialization`
`589`	`589`	`}`