Use byte array in message received to avoid some unnecessary encoding (#2748)

lib/PuppeteerSharp/Cdp/Connection.cs

@@ -285,7 +285,11 @@ private async Task ProcessMessage(MessageReceivedEventArgs e)
                     return;
                 }
 
-                _logger.LogTrace("◀ Receive {Message}", response);
+                if (_logger.IsEnabled(LogLevel.Trace))
+                {
+                    _logger.LogTrace("◀ Receive {Message}", Encoding.UTF8.GetString(response));
+                }
+
                 ProcessIncomingMessage(obj);
             }
             catch (Exception ex)

lib/PuppeteerSharp/Transport/MessageReceivedEventArgs.cs

@@ -12,11 +12,11 @@ public class MessageReceivedEventArgs : EventArgs
         /// Initializes a new instance of the <see cref="PuppeteerSharp.Transport.MessageReceivedEventArgs"/> class.
         /// </summary>
         /// <param name="message">Message.</param>
-        public MessageReceivedEventArgs(string message) => Message = message;
+        public MessageReceivedEventArgs(byte[] message) => Message = message;
 
         /// <summary>
         /// Transport message.
         /// </summary>
-        public string Message { get; }
+        public byte[] Message { get; }
     }
 }

lib/PuppeteerSharp/Transport/WebSocketTransport.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.IO;
 using System.Net.WebSockets;
 using System.Text;
 using System.Threading;
@@ -136,18 +137,16 @@ private static void ScheduleTransportTask(Func<CancellationToken, Task> taskFact
         /// Starts listening the socket.
         /// </summary>
         /// <returns>The start.</returns>
-        private async Task<object> GetResponseAsync(CancellationToken cancellationToken)
+        private async Task GetResponseAsync(CancellationToken cancellationToken)
         {
             var buffer = new byte[2048];
 
             while (!IsClosed)
             {
-                var endOfMessage = false;
-                var response = new StringBuilder();
-
-                while (!endOfMessage)
+                MemoryStream memoryStream = null;
+                WebSocketReceiveResult result;
+                do
                 {
-                    WebSocketReceiveResult result;
                     try
                     {
                         result = await _client.ReceiveAsync(
@@ -156,31 +155,35 @@ private async Task<object> GetResponseAsync(CancellationToken cancellationToken)
                     }
                     catch (OperationCanceledException)
                     {
-                        return null;
+                        return;
                     }
                     catch (Exception ex)
                     {
                         OnClose(ex.Message);
-                        return null;
+                        return;
                     }
 
-                    endOfMessage = result.EndOfMessage;
-
-                    if (result.MessageType == WebSocketMessageType.Text)
+                    if (result.MessageType == WebSocketMessageType.Close)
                     {
-                        response.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
+                        OnClose("WebSocket closed");
+                        return;
                     }
-                    else if (result.MessageType == WebSocketMessageType.Close)
+                    else if (result.MessageType == WebSocketMessageType.Binary)
                     {
-                        OnClose("WebSocket closed");
-                        return null;
+                        continue;
                     }
+
+                    if (memoryStream is null && !result.EndOfMessage)
+                    {
+                        memoryStream = new MemoryStream(buffer.Length);
+                    }
+
+                    memoryStream?.Write(buffer, 0, result.Count);
                 }
+                while (!result.EndOfMessage);
 
-                MessageReceived?.Invoke(this, new MessageReceivedEventArgs(response.ToString()));
+                MessageReceived?.Invoke(this, new MessageReceivedEventArgs(memoryStream is null ? buffer.AsSpan(0, result.Count).ToArray() : memoryStream.ToArray()));
             }
-
-            return null;
         }
 
         private void OnClose(string closeReason)