Respond to corefxlab rename (build break) (#1529)

benaadams · davidfowl · commit 32d6b4296456 · 2017-03-21T08:43:49.000-07:00
diff --git a/src/Microsoft.AspNetCore.Server.Kestrel/Adapter/Internal/AdaptedPipeline.cs b/src/Microsoft.AspNetCore.Server.Kestrel/Adapter/Internal/AdaptedPipeline.cs
@@ -67,7 +67,7 @@ private async Task ReadInputAsync()
 
                 try
                 {
-                    var array = block.Memory.GetArray();
+                    var array = block.Buffer.GetArray();
                     try
                     {
                         bytesRead = await _filteredStream.ReadAsync(array.Array, array.Offset, array.Count);
diff --git a/src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/Connection.cs b/src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/Connection.cs
@@ -234,12 +234,12 @@ private unsafe Libuv.uv_buf_t OnAlloc(UvStreamHandle handle, int suggestedSize)
             var currentWritableBuffer = Input.Writer.Alloc(MinAllocBufferSize);
             _currentWritableBuffer = currentWritableBuffer;
             void* dataPtr;
-            var tryGetPointer = currentWritableBuffer.Memory.TryGetPointer(out dataPtr);
+            var tryGetPointer = currentWritableBuffer.Buffer.TryGetPointer(out dataPtr);
             Debug.Assert(tryGetPointer);
 
             return handle.Libuv.buf_init(
                 (IntPtr)dataPtr,
-                currentWritableBuffer.Memory.Length);
+                currentWritableBuffer.Buffer.Length);
         }
 
         private static void ReadCallback(UvStreamHandle handle, int status, object state)
diff --git a/src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/PipelineExtensions.cs b/src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/PipelineExtensions.cs
@@ -2,11 +2,9 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Diagnostics;
+using System.Buffers;
 using System.IO.Pipelines;
 using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Internal.Http
@@ -85,28 +83,28 @@ public static Span<byte> ToSpan(this ReadableBuffer buffer)
             return buffer.ToArray();
         }
 
-        public static ArraySegment<byte> GetArray(this Memory<byte> memory)
+        public static ArraySegment<byte> GetArray(this Buffer<byte> buffer)
         {
             ArraySegment<byte> result;
-            if (!memory.TryGetArray(out result))
+            if (!buffer.TryGetArray(out result))
             {
-                throw new InvalidOperationException("Memory backed by array was expected");
+                throw new InvalidOperationException("Buffer backed by array was expected");
             }
             return result;
         }
 
         // Temporary until the fast write implementation propagates from corefx
         public unsafe static void WriteFast(this WritableBuffer buffer, ReadOnlySpan<byte> source)
         {
-            var dest = buffer.Memory.Span;
+            var dest = buffer.Buffer.Span;
             var destLength = dest.Length;
 
             if (destLength == 0)
             {
                 buffer.Ensure();
 
                 // Get the new span and length
-                dest = buffer.Memory.Span;
+                dest = buffer.Buffer.Span;
                 destLength = dest.Length;
             }
 
@@ -132,7 +130,7 @@ private static unsafe void WriteMultiBuffer(this WritableBuffer buffer, ReadOnly
             {
                 while (remaining > 0)
                 {
-                    var writable = Math.Min(remaining, buffer.Memory.Length);
+                    var writable = Math.Min(remaining, buffer.Buffer.Length);
 
                     buffer.Ensure(writable);
 
@@ -141,7 +139,7 @@ private static unsafe void WriteMultiBuffer(this WritableBuffer buffer, ReadOnly
                         continue;
                     }
 
-                    fixed (byte* pDest = &buffer.Memory.Span.DangerousGetPinnableReference())
+                    fixed (byte* pDest = &buffer.Buffer.Span.DangerousGetPinnableReference())
                     {
                         Unsafe.CopyBlockUnaligned(pDest, pSource + offset, (uint)writable);
                     }
@@ -158,16 +156,16 @@ public unsafe static void WriteAscii(this WritableBuffer buffer, string data)
         {
             if (!string.IsNullOrEmpty(data))
             {
-                if (buffer.Memory.IsEmpty)
+                if (buffer.Buffer.IsEmpty)
                 {
                     buffer.Ensure();
                 }
 
                 // Fast path, try copying to the available memory directly
-                if (data.Length <= buffer.Memory.Length)
+                if (data.Length <= buffer.Buffer.Length)
                 {
                     fixed (char* input = data)
-                    fixed (byte* output = &buffer.Memory.Span.DangerousGetPinnableReference())
+                    fixed (byte* output = &buffer.Buffer.Span.DangerousGetPinnableReference())
                     {
                         EncodeAsciiCharsToBytes(input, output, data.Length);
                     }
@@ -186,15 +184,15 @@ public unsafe static void WriteNumeric(this WritableBuffer buffer, ulong number)
         {
             const byte AsciiDigitStart = (byte)'0';
 
-            if (buffer.Memory.IsEmpty)
+            if (buffer.Buffer.IsEmpty)
             {
                 buffer.Ensure();
             }
 
             // Fast path, try copying to the available memory directly
-            var bytesLeftInBlock = buffer.Memory.Length;
+            var bytesLeftInBlock = buffer.Buffer.Length;
             var simpleWrite = true;
-            fixed (byte* output = &buffer.Memory.Span.DangerousGetPinnableReference())
+            fixed (byte* output = &buffer.Buffer.Span.DangerousGetPinnableReference())
             {
                 var start = output;
                 if (number < 10 && bytesLeftInBlock >= 1)
@@ -266,7 +264,7 @@ private unsafe static void WriteAsciiMultiWrite(this WritableBuffer buffer, stri
 
                 while (remaining > 0)
                 {
-                    var writable = Math.Min(remaining, buffer.Memory.Length);
+                    var writable = Math.Min(remaining, buffer.Buffer.Length);
 
                     buffer.Ensure(writable);
 
@@ -275,7 +273,7 @@ private unsafe static void WriteAsciiMultiWrite(this WritableBuffer buffer, stri
                         continue;
                     }
 
-                    fixed (byte* output = &buffer.Memory.Span.DangerousGetPinnableReference())
+                    fixed (byte* output = &buffer.Buffer.Span.DangerousGetPinnableReference())
                     {
                         EncodeAsciiCharsToBytes(inputSlice, output, writable);
                     }
diff --git a/src/Microsoft.AspNetCore.Server.Kestrel/Internal/Networking/UvWriteReq.cs b/src/Microsoft.AspNetCore.Server.Kestrel/Internal/Networking/UvWriteReq.cs
@@ -26,7 +26,7 @@ public class UvWriteReq : UvRequest
 
         private LibuvAwaitable<UvWriteReq> _awaitable = new LibuvAwaitable<UvWriteReq>();
         private List<GCHandle> _pins = new List<GCHandle>(BUFFER_COUNT + 1);
-        private List<MemoryHandle> _handles = new List<MemoryHandle>(BUFFER_COUNT + 1);
+        private List<BufferHandle> _handles = new List<BufferHandle>(BUFFER_COUNT + 1);
 
         public UvWriteReq(IKestrelTrace logger) : base(logger)
         {
diff --git a/test/Microsoft.AspNetCore.Server.KestrelTests/MessageBodyTests.cs b/test/Microsoft.AspNetCore.Server.KestrelTests/MessageBodyTests.cs
@@ -285,7 +285,7 @@ public async Task CopyToAsyncDoesNotCopyBlocks(FrameRequestHeaders headers, stri
                 var bytes = Encoding.ASCII.GetBytes(data[0]);
                 var buffer = socketInput.Writer.Alloc(2048);
                 ArraySegment<byte> block;
-                Assert.True(buffer.Memory.TryGetArray(out block));
+                Assert.True(buffer.Buffer.TryGetArray(out block));
                 Buffer.BlockCopy(bytes, 0, block.Array, block.Offset, bytes.Length);
                 buffer.Advance(bytes.Length);
                 await buffer.FlushAsync();
@@ -296,7 +296,7 @@ public async Task CopyToAsyncDoesNotCopyBlocks(FrameRequestHeaders headers, stri
                 writeTcs = new TaskCompletionSource<byte[]>();
                 bytes = Encoding.ASCII.GetBytes(data[1]);
                 buffer = socketInput.Writer.Alloc(2048);
-                Assert.True(buffer.Memory.TryGetArray(out block));
+                Assert.True(buffer.Buffer.TryGetArray(out block));
                 Buffer.BlockCopy(bytes, 0, block.Array, block.Offset, bytes.Length);
                 buffer.Advance(bytes.Length);
                 await buffer.FlushAsync();

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ private async Task ReadInputAsync()`
`67`	`67`
`68`	`68`	`try`
`69`	`69`	`{`
`70`		`- var array = block.Memory.GetArray();`
	`70`	`+ var array = block.Buffer.GetArray();`
`71`	`71`	`try`
`72`	`72`	`{`
`73`	`73`	`bytesRead = await _filteredStream.ReadAsync(array.Array, array.Offset, array.Count);`
Original file line number	Diff line number	Diff line change
`@@ -2,11 +2,9 @@`
`2`	`2`	`// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.`
`3`	`3`
`4`	`4`	`using System;`
`5`		`-using System.Diagnostics;`
	`5`	`+using System.Buffers;`
`6`	`6`	`using System.IO.Pipelines;`
`7`	`7`	`using System.Runtime.CompilerServices;`
`8`		`-using System.Text;`
`9`		`-using System.Threading;`
`10`	`8`	`using System.Threading.Tasks;`
`11`	`9`
`12`	`10`	`namespace Microsoft.AspNetCore.Server.Kestrel.Internal.Http`
`@@ -85,28 +83,28 @@ public static Span<byte> ToSpan(this ReadableBuffer buffer)`
`85`	`83`	`return buffer.ToArray();`
`86`	`84`	`}`
`87`	`85`
`88`		`- public static ArraySegment<byte> GetArray(this Memory<byte> memory)`
	`86`	`+ public static ArraySegment<byte> GetArray(this Buffer<byte> buffer)`
`89`	`87`	`{`
`90`	`88`	`ArraySegment<byte> result;`
`91`		`- if (!memory.TryGetArray(out result))`
	`89`	`+ if (!buffer.TryGetArray(out result))`
`92`	`90`	`{`
`93`		`- throw new InvalidOperationException("Memory backed by array was expected");`
	`91`	`+ throw new InvalidOperationException("Buffer backed by array was expected");`
`94`	`92`	`}`
`95`	`93`	`return result;`
`96`	`94`	`}`
`97`	`95`
`98`	`96`	`// Temporary until the fast write implementation propagates from corefx`
`99`	`97`	`public unsafe static void WriteFast(this WritableBuffer buffer, ReadOnlySpan<byte> source)`
`100`	`98`	`{`
`101`		`- var dest = buffer.Memory.Span;`
	`99`	`+ var dest = buffer.Buffer.Span;`
`102`	`100`	`var destLength = dest.Length;`
`103`	`101`
`104`	`102`	`if (destLength == 0)`
`105`	`103`	`{`
`106`	`104`	`buffer.Ensure();`
`107`	`105`
`108`	`106`	`// Get the new span and length`
`109`		`- dest = buffer.Memory.Span;`
	`107`	`+ dest = buffer.Buffer.Span;`
`110`	`108`	`destLength = dest.Length;`
`111`	`109`	`}`
`112`	`110`
`@@ -132,7 +130,7 @@ private static unsafe void WriteMultiBuffer(this WritableBuffer buffer, ReadOnly`
`132`	`130`	`{`
`133`	`131`	`while (remaining > 0)`
`134`	`132`	`{`
`135`		`- var writable = Math.Min(remaining, buffer.Memory.Length);`
	`133`	`+ var writable = Math.Min(remaining, buffer.Buffer.Length);`
`136`	`134`
`137`	`135`	`buffer.Ensure(writable);`
`138`	`136`
`@@ -141,7 +139,7 @@ private static unsafe void WriteMultiBuffer(this WritableBuffer buffer, ReadOnly`
`141`	`139`	`continue;`
`142`	`140`	`}`
`143`	`141`
`144`		`- fixed (byte* pDest = &buffer.Memory.Span.DangerousGetPinnableReference())`
	`142`	`+ fixed (byte* pDest = &buffer.Buffer.Span.DangerousGetPinnableReference())`
`145`	`143`	`{`
`146`	`144`	`Unsafe.CopyBlockUnaligned(pDest, pSource + offset, (uint)writable);`
`147`	`145`	`}`
`@@ -158,16 +156,16 @@ public unsafe static void WriteAscii(this WritableBuffer buffer, string data)`
`158`	`156`	`{`
`159`	`157`	`if (!string.IsNullOrEmpty(data))`
`160`	`158`	`{`
`161`		`- if (buffer.Memory.IsEmpty)`
	`159`	`+ if (buffer.Buffer.IsEmpty)`
`162`	`160`	`{`
`163`	`161`	`buffer.Ensure();`
`164`	`162`	`}`
`165`	`163`
`166`	`164`	`// Fast path, try copying to the available memory directly`
`167`		`- if (data.Length <= buffer.Memory.Length)`
	`165`	`+ if (data.Length <= buffer.Buffer.Length)`
`168`	`166`	`{`
`169`	`167`	`fixed (char* input = data)`
`170`		`- fixed (byte* output = &buffer.Memory.Span.DangerousGetPinnableReference())`
	`168`	`+ fixed (byte* output = &buffer.Buffer.Span.DangerousGetPinnableReference())`
`171`	`169`	`{`
`172`	`170`	`EncodeAsciiCharsToBytes(input, output, data.Length);`
`173`	`171`	`}`
`@@ -186,15 +184,15 @@ public unsafe static void WriteNumeric(this WritableBuffer buffer, ulong number)`
`186`	`184`	`{`
`187`	`185`	`const byte AsciiDigitStart = (byte)'0';`
`188`	`186`
`189`		`- if (buffer.Memory.IsEmpty)`
	`187`	`+ if (buffer.Buffer.IsEmpty)`
`190`	`188`	`{`
`191`	`189`	`buffer.Ensure();`
`192`	`190`	`}`
`193`	`191`
`194`	`192`	`// Fast path, try copying to the available memory directly`
`195`		`- var bytesLeftInBlock = buffer.Memory.Length;`
	`193`	`+ var bytesLeftInBlock = buffer.Buffer.Length;`
`196`	`194`	`var simpleWrite = true;`
`197`		`- fixed (byte* output = &buffer.Memory.Span.DangerousGetPinnableReference())`
	`195`	`+ fixed (byte* output = &buffer.Buffer.Span.DangerousGetPinnableReference())`
`198`	`196`	`{`
`199`	`197`	`var start = output;`
`200`	`198`	`if (number < 10 && bytesLeftInBlock >= 1)`
`@@ -266,7 +264,7 @@ private unsafe static void WriteAsciiMultiWrite(this WritableBuffer buffer, stri`
`266`	`264`
`267`	`265`	`while (remaining > 0)`
`268`	`266`	`{`
`269`		`- var writable = Math.Min(remaining, buffer.Memory.Length);`
	`267`	`+ var writable = Math.Min(remaining, buffer.Buffer.Length);`
`270`	`268`
`271`	`269`	`buffer.Ensure(writable);`
`272`	`270`
`@@ -275,7 +273,7 @@ private unsafe static void WriteAsciiMultiWrite(this WritableBuffer buffer, stri`
`275`	`273`	`continue;`
`276`	`274`	`}`
`277`	`275`
`278`		`- fixed (byte* output = &buffer.Memory.Span.DangerousGetPinnableReference())`
	`276`	`+ fixed (byte* output = &buffer.Buffer.Span.DangerousGetPinnableReference())`
`279`	`277`	`{`
`280`	`278`	`EncodeAsciiCharsToBytes(inputSlice, output, writable);`
`281`	`279`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public class UvWriteReq : UvRequest`
`26`	`26`
`27`	`27`	`private LibuvAwaitable<UvWriteReq> _awaitable = new LibuvAwaitable<UvWriteReq>();`
`28`	`28`	`private List<GCHandle> _pins = new List<GCHandle>(BUFFER_COUNT + 1);`
`29`		`- private List<MemoryHandle> _handles = new List<MemoryHandle>(BUFFER_COUNT + 1);`
	`29`	`+ private List<BufferHandle> _handles = new List<BufferHandle>(BUFFER_COUNT + 1);`
`30`	`30`
`31`	`31`	`public UvWriteReq(IKestrelTrace logger) : base(logger)`
`32`	`32`	`{`