Merge branch 'trunk' into devtools-event-args

RenderMichael · web-flow · commit 0cbe3f283835 · 2025-02-07T16:36:13.000-05:00
diff --git a/dotnet/src/webdriver/BiDi/Communication/Broker.cs b/dotnet/src/webdriver/BiDi/Communication/Broker.cs
@@ -70,6 +70,7 @@ internal Broker(BiDi bidi, ITransport transport)
             {
                 new BrowsingContextConverter(_bidi),
                 new BrowserUserContextConverter(bidi),
+                new BrowserClientWindowConverter(),
                 new NavigationConverter(),
                 new InterceptConverter(_bidi),
                 new RequestConverter(_bidi),
@@ -97,6 +98,7 @@ internal Broker(BiDi bidi, ITransport transport)
                 new Json.Converters.Enumerable.LocateNodesResultConverter(),
                 new Json.Converters.Enumerable.InputSourceActionsConverter(),
                 new Json.Converters.Enumerable.GetUserContextsResultConverter(),
+                new Json.Converters.Enumerable.GetClientWindowsResultConverter(),
                 new Json.Converters.Enumerable.GetRealmsResultConverter(),
             }
         };
@@ -109,15 +111,17 @@ public async Task ConnectAsync(CancellationToken cancellationToken)
         await _transport.ConnectAsync(cancellationToken).ConfigureAwait(false);
 
         _receiveMessagesCancellationTokenSource = new CancellationTokenSource();
-        _receivingMessageTask = _myTaskFactory.StartNew(async () => await ReceiveMessagesAsync(_receiveMessagesCancellationTokenSource.Token), TaskCreationOptions.LongRunning).Unwrap();
-        _eventEmitterTask = _myTaskFactory.StartNew(async () => await ProcessEventsAwaiterAsync(), TaskCreationOptions.LongRunning).Unwrap();
+        _receivingMessageTask = _myTaskFactory.StartNew(async () => await ReceiveMessagesAsync(_receiveMessagesCancellationTokenSource.Token)).Unwrap();
+        _eventEmitterTask = _myTaskFactory.StartNew(ProcessEventsAwaiterAsync).Unwrap();
     }
 
     private async Task ReceiveMessagesAsync(CancellationToken cancellationToken)
     {
         while (!cancellationToken.IsCancellationRequested)
         {
-            var message = await _transport.ReceiveAsJsonAsync<Message>(_jsonSerializerContext, cancellationToken);
+            var data = await _transport.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+
+            var message = JsonSerializer.Deserialize(new ReadOnlySpan<byte>(data), _jsonSerializerContext.Message);
 
             switch (message)
             {
@@ -177,21 +181,21 @@ private async Task ProcessEventsAwaiterAsync()
     }
 
     public async Task<TResult> ExecuteCommandAsync<TCommand, TResult>(TCommand command, CommandOptions? options)
-        where TCommand: Command
+        where TCommand : Command
     {
         var jsonElement = await ExecuteCommandCoreAsync(command, options).ConfigureAwait(false);
 
         return (TResult)jsonElement.Deserialize(typeof(TResult), _jsonSerializerContext)!;
     }
 
     public async Task ExecuteCommandAsync<TCommand>(TCommand command, CommandOptions? options)
-        where TCommand: Command
+        where TCommand : Command
     {
         await ExecuteCommandCoreAsync(command, options).ConfigureAwait(false);
     }
 
     private async Task<JsonElement> ExecuteCommandCoreAsync<TCommand>(TCommand command, CommandOptions? options)
-        where TCommand: Command
+        where TCommand : Command
     {
         command.Id = Interlocked.Increment(ref _currentCommandId);
 
@@ -205,7 +209,9 @@ private async Task<JsonElement> ExecuteCommandCoreAsync<TCommand>(TCommand comma
 
         _pendingCommands[command.Id] = tcs;
 
-        await _transport.SendAsJsonAsync(command, _jsonSerializerContext, cts.Token).ConfigureAwait(false);
+        var data = JsonSerializer.SerializeToUtf8Bytes(command, typeof(TCommand), _jsonSerializerContext);
+
+        await _transport.SendAsync(data, cts.Token).ConfigureAwait(false);
 
         return await tcs.Task.ConfigureAwait(false);
     }
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/BiDiJsonSerializerContext.cs b/dotnet/src/webdriver/BiDi/Communication/Json/BiDiJsonSerializerContext.cs
@@ -86,8 +86,11 @@ namespace OpenQA.Selenium.BiDi.Communication.Json;
 [JsonSerializable(typeof(Modules.Browser.GetUserContextsCommand))]
 [JsonSerializable(typeof(Modules.Browser.GetUserContextsResult))]
 [JsonSerializable(typeof(Modules.Browser.RemoveUserContextCommand))]
+[JsonSerializable(typeof(Modules.Browser.GetClientWindowsCommand))]
+[JsonSerializable(typeof(Modules.Browser.GetClientWindowsResult))]
 [JsonSerializable(typeof(Modules.Browser.UserContextInfo))]
 [JsonSerializable(typeof(IReadOnlyList<Modules.Browser.UserContextInfo>))]
+[JsonSerializable(typeof(IReadOnlyList<Modules.Browser.ClientWindowInfo>))]
 
 
 [JsonSerializable(typeof(Modules.BrowsingContext.ActivateCommand))]
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/Converters/BrowserClientWindowConverter.cs b/dotnet/src/webdriver/BiDi/Communication/Json/Converters/BrowserClientWindowConverter.cs
@@ -0,0 +1,42 @@
+// <copyright file="BrowserClientWindowConverter.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+using OpenQA.Selenium.BiDi.Modules.Browser;
+using System;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+#nullable enable
+
+namespace OpenQA.Selenium.BiDi.Communication.Json.Converters;
+
+internal class BrowserClientWindowConverter : JsonConverter<ClientWindow>
+{
+    public override ClientWindow? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        var id = reader.GetString();
+
+        return new ClientWindow(id!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, ClientWindow value, JsonSerializerOptions options)
+    {
+        writer.WriteStringValue(value.Id);
+    }
+}
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetClientWindowsResultConverter.cs b/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetClientWindowsResultConverter.cs
@@ -0,0 +1,44 @@
+// <copyright file="GetClientWindowsResultConverter.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+using OpenQA.Selenium.BiDi.Modules.Browser;
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+#nullable enable
+
+namespace OpenQA.Selenium.BiDi.Communication.Json.Converters.Enumerable;
+
+internal class GetClientWindowsResultConverter : JsonConverter<GetClientWindowsResult>
+{
+    public override GetClientWindowsResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        using var doc = JsonDocument.ParseValue(ref reader);
+        var clientWindows = doc.RootElement.GetProperty("clientWindows").Deserialize<IReadOnlyList<ClientWindowInfo>>(options);
+
+        return new GetClientWindowsResult(clientWindows!);
+    }
+
+    public override void Write(Utf8JsonWriter writer, GetClientWindowsResult value, JsonSerializerOptions options)
+    {
+        throw new NotImplementedException();
+    }
+}
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetCookiesResultConverter.cs b/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetCookiesResultConverter.cs
@@ -31,7 +31,7 @@ internal class GetCookiesResultConverter : JsonConverter<GetCookiesResult>
 {
     public override GetCookiesResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
-        var doc = JsonDocument.ParseValue(ref reader);
+        using var doc = JsonDocument.ParseValue(ref reader);
         var cookies = doc.RootElement.GetProperty("cookies").Deserialize<IReadOnlyList<Modules.Network.Cookie>>(options);
         var partitionKey = doc.RootElement.GetProperty("partitionKey").Deserialize<PartitionKey>(options);
 
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetRealmsResultConverter.cs b/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetRealmsResultConverter.cs
@@ -31,7 +31,7 @@ internal class GetRealmsResultConverter : JsonConverter<GetRealmsResult>
 {
     public override GetRealmsResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
-        var doc = JsonDocument.ParseValue(ref reader);
+        using var doc = JsonDocument.ParseValue(ref reader);
         var realms = doc.RootElement.GetProperty("realms").Deserialize<IReadOnlyList<RealmInfo>>(options);
 
         return new GetRealmsResult(realms!);
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetUserContextsResultConverter.cs b/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/GetUserContextsResultConverter.cs
@@ -31,7 +31,7 @@ internal class GetUserContextsResultConverter : JsonConverter<GetUserContextsRes
 {
     public override GetUserContextsResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
-        var doc = JsonDocument.ParseValue(ref reader);
+        using var doc = JsonDocument.ParseValue(ref reader);
         var userContexts = doc.RootElement.GetProperty("userContexts").Deserialize<IReadOnlyList<UserContextInfo>>(options);
 
         return new GetUserContextsResult(userContexts!);
diff --git a/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/LocateNodesResultConverter.cs b/dotnet/src/webdriver/BiDi/Communication/Json/Converters/Enumerable/LocateNodesResultConverter.cs
@@ -32,7 +32,7 @@ internal class LocateNodesResultConverter : JsonConverter<LocateNodesResult>
 {
     public override LocateNodesResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
-        var doc = JsonDocument.ParseValue(ref reader);
+        using var doc = JsonDocument.ParseValue(ref reader);
         var nodes = doc.RootElement.GetProperty("nodes").Deserialize<IReadOnlyList<RemoteValue.Node>>(options);
 
         return new LocateNodesResult(nodes!);
diff --git a/dotnet/src/webdriver/BiDi/Communication/Transport/ITransport.cs b/dotnet/src/webdriver/BiDi/Communication/Transport/ITransport.cs
@@ -20,7 +20,6 @@
 using System.Threading.Tasks;
 using System.Threading;
 using System;
-using System.Text.Json.Serialization;
 
 #nullable enable
 
@@ -30,8 +29,7 @@ interface ITransport : IDisposable
 {
     Task ConnectAsync(CancellationToken cancellationToken);
 
-    Task<T> ReceiveAsJsonAsync<T>(JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken);
+    Task<byte[]> ReceiveAsync(CancellationToken cancellationToken);
 
-    Task SendAsJsonAsync<TCommand>(TCommand command, JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken)
-        where TCommand : Command;
+    Task SendAsync(byte[] data, CancellationToken cancellationToken);
 }
diff --git a/dotnet/src/webdriver/BiDi/Communication/Transport/WebSocketTransport.cs b/dotnet/src/webdriver/BiDi/Communication/Transport/WebSocketTransport.cs
@@ -22,10 +22,8 @@
 using System.Net.WebSockets;
 using System.Threading.Tasks;
 using System.Threading;
-using System.Text.Json;
 using System.Text;
 using OpenQA.Selenium.Internal.Logging;
-using System.Text.Json.Serialization;
 
 #nullable enable
 
@@ -45,7 +43,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken)
         await _webSocket.ConnectAsync(_uri, cancellationToken).ConfigureAwait(false);
     }
 
-    public async Task<T> ReceiveAsJsonAsync<T>(JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken)
+    public async Task<byte[]> ReceiveAsync(CancellationToken cancellationToken)
     {
         using var ms = new MemoryStream();
 
@@ -61,31 +59,28 @@ public async Task<T> ReceiveAsJsonAsync<T>(JsonSerializerContext jsonSerializerC
 
         ms.Seek(0, SeekOrigin.Begin);
 
+        byte[] data = ms.ToArray();
+
         if (_logger.IsEnabled(LogEventLevel.Trace))
         {
-            _logger.Trace($"BiDi RCV <-- {Encoding.UTF8.GetString(ms.ToArray())}");
+            _logger.Trace($"BiDi RCV <-- {Encoding.UTF8.GetString(data)}");
         }
 
-        var res = await JsonSerializer.DeserializeAsync(ms, typeof(T), jsonSerializerContext, cancellationToken).ConfigureAwait(false);
-
-        return (T)res!;
+        return data;
     }
 
-    public async Task SendAsJsonAsync<TCommand>(TCommand command, JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken)
-        where TCommand : Command
+    public async Task SendAsync(byte[] data, CancellationToken cancellationToken)
     {
-        var buffer = JsonSerializer.SerializeToUtf8Bytes(command, typeof(TCommand), jsonSerializerContext);
-
         await _socketSendSemaphoreSlim.WaitAsync(cancellationToken);
 
         try
         {
             if (_logger.IsEnabled(LogEventLevel.Trace))
             {
-                _logger.Trace($"BiDi SND --> {Encoding.UTF8.GetString(buffer)}");
+                _logger.Trace($"BiDi SND --> {Encoding.UTF8.GetString(data)}");
             }
 
-            await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
+            await _webSocket.SendAsync(new ArraySegment<byte>(data), WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);
         }
         finally
         {
diff --git a/dotnet/src/webdriver/BiDi/Modules/Browser/BrowserModule.cs b/dotnet/src/webdriver/BiDi/Modules/Browser/BrowserModule.cs
@@ -48,4 +48,9 @@ public async Task RemoveUserContextAsync(UserContext userContext, RemoveUserCont
 
         await Broker.ExecuteCommandAsync(new RemoveUserContextCommand(@params), options).ConfigureAwait(false);
     }
+
+    public async Task<GetClientWindowsResult> GetClientWindowsAsync(GetClientWindowsOptions? options = null)
+    {
+        return await Broker.ExecuteCommandAsync<GetClientWindowsCommand, GetClientWindowsResult>(new(), options).ConfigureAwait(false);
+    }
 }
diff --git a/dotnet/src/webdriver/BiDi/Modules/Browser/ClientWindow.cs b/dotnet/src/webdriver/BiDi/Modules/Browser/ClientWindow.cs
@@ -0,0 +1,32 @@
+// <copyright file="ClientWindow.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+#nullable enable
+
+namespace OpenQA.Selenium.BiDi.Modules.Browser;
+
+public record ClientWindow
+{
+    internal ClientWindow(string id)
+    {
+        Id = id;
+    }
+
+    internal string Id { get; }
+}
diff --git a/dotnet/src/webdriver/BiDi/Modules/Browser/ClientWindowInfo.cs b/dotnet/src/webdriver/BiDi/Modules/Browser/ClientWindowInfo.cs
@@ -0,0 +1,34 @@
+// <copyright file="ClientWindowInfo.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+#nullable enable
+
+using System.Text.Json.Serialization;
+
+namespace OpenQA.Selenium.BiDi.Modules.Browser;
+
+public record ClientWindowInfo([property: JsonPropertyName("active")] bool IsActive, ClientWindow ClientWindow, ClientWindowState State, int Height, int Width, int X, int Y);
+
+public enum ClientWindowState
+{
+    Fullscreen,
+    Maximized,
+    Minimized,
+    Normal
+}
diff --git a/dotnet/src/webdriver/BiDi/Modules/Browser/GetClientWindowsCommand.cs b/dotnet/src/webdriver/BiDi/Modules/Browser/GetClientWindowsCommand.cs
diff --git a/dotnet/src/webdriver/BiDi/Modules/BrowsingContext/BrowsingContextInfo.cs b/dotnet/src/webdriver/BiDi/Modules/BrowsingContext/BrowsingContextInfo.cs
diff --git a/dotnet/test/common/BiDi/Browser/BrowserTest.cs b/dotnet/test/common/BiDi/Browser/BrowserTest.cs

Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,7 @@ internal Broker(BiDi bidi, ITransport transport)`
`70`	`70`	`{`
`71`	`71`	`new BrowsingContextConverter(_bidi),`
`72`	`72`	`new BrowserUserContextConverter(bidi),`
	`73`	`+ new BrowserClientWindowConverter(),`
`73`	`74`	`new NavigationConverter(),`
`74`	`75`	`new InterceptConverter(_bidi),`
`75`	`76`	`new RequestConverter(_bidi),`
`@@ -97,6 +98,7 @@ internal Broker(BiDi bidi, ITransport transport)`
`97`	`98`	`new Json.Converters.Enumerable.LocateNodesResultConverter(),`
`98`	`99`	`new Json.Converters.Enumerable.InputSourceActionsConverter(),`
`99`	`100`	`new Json.Converters.Enumerable.GetUserContextsResultConverter(),`
	`101`	`+ new Json.Converters.Enumerable.GetClientWindowsResultConverter(),`
`100`	`102`	`new Json.Converters.Enumerable.GetRealmsResultConverter(),`
`101`	`103`	`}`
`102`	`104`	`};`
`@@ -109,15 +111,17 @@ public async Task ConnectAsync(CancellationToken cancellationToken)`
`109`	`111`	`await _transport.ConnectAsync(cancellationToken).ConfigureAwait(false);`
`110`	`112`
`111`	`113`	`_receiveMessagesCancellationTokenSource = new CancellationTokenSource();`
`112`		`- _receivingMessageTask = _myTaskFactory.StartNew(async () => await ReceiveMessagesAsync(_receiveMessagesCancellationTokenSource.Token), TaskCreationOptions.LongRunning).Unwrap();`
`113`		`- _eventEmitterTask = _myTaskFactory.StartNew(async () => await ProcessEventsAwaiterAsync(), TaskCreationOptions.LongRunning).Unwrap();`
	`114`	`+ _receivingMessageTask = _myTaskFactory.StartNew(async () => await ReceiveMessagesAsync(_receiveMessagesCancellationTokenSource.Token)).Unwrap();`
	`115`	`+ _eventEmitterTask = _myTaskFactory.StartNew(ProcessEventsAwaiterAsync).Unwrap();`
`114`	`116`	`}`
`115`	`117`
`116`	`118`	`private async Task ReceiveMessagesAsync(CancellationToken cancellationToken)`
`117`	`119`	`{`
`118`	`120`	`while (!cancellationToken.IsCancellationRequested)`
`119`	`121`	`{`
`120`		`- var message = await _transport.ReceiveAsJsonAsync<Message>(_jsonSerializerContext, cancellationToken);`
	`122`	`+ var data = await _transport.ReceiveAsync(cancellationToken).ConfigureAwait(false);`
	`123`	`+`
	`124`	`+ var message = JsonSerializer.Deserialize(new ReadOnlySpan<byte>(data), _jsonSerializerContext.Message);`
`121`	`125`
`122`	`126`	`switch (message)`
`123`	`127`	`{`
`@@ -177,21 +181,21 @@ private async Task ProcessEventsAwaiterAsync()`
`177`	`181`	`}`
`178`	`182`
`179`	`183`	`public async Task<TResult> ExecuteCommandAsync<TCommand, TResult>(TCommand command, CommandOptions? options)`
`180`		`- where TCommand: Command`
	`184`	`+ where TCommand : Command`
`181`	`185`	`{`
`182`	`186`	`var jsonElement = await ExecuteCommandCoreAsync(command, options).ConfigureAwait(false);`
`183`	`187`
`184`	`188`	`return (TResult)jsonElement.Deserialize(typeof(TResult), _jsonSerializerContext)!;`
`185`	`189`	`}`
`186`	`190`
`187`	`191`	`public async Task ExecuteCommandAsync<TCommand>(TCommand command, CommandOptions? options)`
`188`		`- where TCommand: Command`
	`192`	`+ where TCommand : Command`
`189`	`193`	`{`
`190`	`194`	`await ExecuteCommandCoreAsync(command, options).ConfigureAwait(false);`
`191`	`195`	`}`
`192`	`196`
`193`	`197`	`private async Task<JsonElement> ExecuteCommandCoreAsync<TCommand>(TCommand command, CommandOptions? options)`
`194`		`- where TCommand: Command`
	`198`	`+ where TCommand : Command`
`195`	`199`	`{`
`196`	`200`	`command.Id = Interlocked.Increment(ref _currentCommandId);`
`197`	`201`
`@@ -205,7 +209,9 @@ private async Task<JsonElement> ExecuteCommandCoreAsync<TCommand>(TCommand comma`
`205`	`209`
`206`	`210`	`_pendingCommands[command.Id] = tcs;`
`207`	`211`
`208`		`- await _transport.SendAsJsonAsync(command, _jsonSerializerContext, cts.Token).ConfigureAwait(false);`
	`212`	`+ var data = JsonSerializer.SerializeToUtf8Bytes(command, typeof(TCommand), _jsonSerializerContext);`
	`213`	`+`
	`214`	`+ await _transport.SendAsync(data, cts.Token).ConfigureAwait(false);`
`209`	`215`
`210`	`216`	`return await tcs.Task.ConfigureAwait(false);`
`211`	`217`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ internal class GetCookiesResultConverter : JsonConverter<GetCookiesResult>`
`31`	`31`	`{`
`32`	`32`	`public override GetCookiesResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`33`	`33`	`{`
`34`		`- var doc = JsonDocument.ParseValue(ref reader);`
	`34`	`+ using var doc = JsonDocument.ParseValue(ref reader);`
`35`	`35`	`var cookies = doc.RootElement.GetProperty("cookies").Deserialize<IReadOnlyList<Modules.Network.Cookie>>(options);`
`36`	`36`	`var partitionKey = doc.RootElement.GetProperty("partitionKey").Deserialize<PartitionKey>(options);`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ internal class GetRealmsResultConverter : JsonConverter<GetRealmsResult>`
`31`	`31`	`{`
`32`	`32`	`public override GetRealmsResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`33`	`33`	`{`
`34`		`- var doc = JsonDocument.ParseValue(ref reader);`
	`34`	`+ using var doc = JsonDocument.ParseValue(ref reader);`
`35`	`35`	`var realms = doc.RootElement.GetProperty("realms").Deserialize<IReadOnlyList<RealmInfo>>(options);`
`36`	`36`
`37`	`37`	`return new GetRealmsResult(realms!);`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ internal class GetUserContextsResultConverter : JsonConverter<GetUserContextsRes`
`31`	`31`	`{`
`32`	`32`	`public override GetUserContextsResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`33`	`33`	`{`
`34`		`- var doc = JsonDocument.ParseValue(ref reader);`
	`34`	`+ using var doc = JsonDocument.ParseValue(ref reader);`
`35`	`35`	`var userContexts = doc.RootElement.GetProperty("userContexts").Deserialize<IReadOnlyList<UserContextInfo>>(options);`
`36`	`36`
`37`	`37`	`return new GetUserContextsResult(userContexts!);`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ internal class LocateNodesResultConverter : JsonConverter<LocateNodesResult>`
`32`	`32`	`{`
`33`	`33`	`public override LocateNodesResult Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)`
`34`	`34`	`{`
`35`		`- var doc = JsonDocument.ParseValue(ref reader);`
	`35`	`+ using var doc = JsonDocument.ParseValue(ref reader);`
`36`	`36`	`var nodes = doc.RootElement.GetProperty("nodes").Deserialize<IReadOnlyList<RemoteValue.Node>>(options);`
`37`	`37`
`38`	`38`	`return new LocateNodesResult(nodes!);`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@`
`20`	`20`	`using System.Threading.Tasks;`
`21`	`21`	`using System.Threading;`
`22`	`22`	`using System;`
`23`		`-using System.Text.Json.Serialization;`
`24`	`23`
`25`	`24`	`#nullable enable`
`26`	`25`
`@@ -30,8 +29,7 @@ interface ITransport : IDisposable`
`30`	`29`	`{`
`31`	`30`	`Task ConnectAsync(CancellationToken cancellationToken);`
`32`	`31`
`33`		`- Task<T> ReceiveAsJsonAsync<T>(JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken);`
	`32`	`+ Task<byte[]> ReceiveAsync(CancellationToken cancellationToken);`
`34`	`33`
`35`		`- Task SendAsJsonAsync<TCommand>(TCommand command, JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken)`
`36`		`- where TCommand : Command;`
	`34`	`+ Task SendAsync(byte[] data, CancellationToken cancellationToken);`
`37`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,8 @@`
`22`	`22`	`using System.Net.WebSockets;`
`23`	`23`	`using System.Threading.Tasks;`
`24`	`24`	`using System.Threading;`
`25`		`-using System.Text.Json;`
`26`	`25`	`using System.Text;`
`27`	`26`	`using OpenQA.Selenium.Internal.Logging;`
`28`		`-using System.Text.Json.Serialization;`
`29`	`27`
`30`	`28`	`#nullable enable`
`31`	`29`
`@@ -45,7 +43,7 @@ public async Task ConnectAsync(CancellationToken cancellationToken)`
`45`	`43`	`await _webSocket.ConnectAsync(_uri, cancellationToken).ConfigureAwait(false);`
`46`	`44`	`}`
`47`	`45`
`48`		`- public async Task<T> ReceiveAsJsonAsync<T>(JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken)`
	`46`	`+ public async Task<byte[]> ReceiveAsync(CancellationToken cancellationToken)`
`49`	`47`	`{`
`50`	`48`	`using var ms = new MemoryStream();`
`51`	`49`
`@@ -61,31 +59,28 @@ public async Task<T> ReceiveAsJsonAsync<T>(JsonSerializerContext jsonSerializerC`
`61`	`59`
`62`	`60`	`ms.Seek(0, SeekOrigin.Begin);`
`63`	`61`
	`62`	`+ byte[] data = ms.ToArray();`
	`63`	`+`
`64`	`64`	`if (_logger.IsEnabled(LogEventLevel.Trace))`
`65`	`65`	`{`
`66`		`- _logger.Trace($"BiDi RCV <-- {Encoding.UTF8.GetString(ms.ToArray())}");`
	`66`	`+ _logger.Trace($"BiDi RCV <-- {Encoding.UTF8.GetString(data)}");`
`67`	`67`	`}`
`68`	`68`
`69`		`- var res = await JsonSerializer.DeserializeAsync(ms, typeof(T), jsonSerializerContext, cancellationToken).ConfigureAwait(false);`
`70`		`-`
`71`		`- return (T)res!;`
	`69`	`+ return data;`
`72`	`70`	`}`
`73`	`71`
`74`		`- public async Task SendAsJsonAsync<TCommand>(TCommand command, JsonSerializerContext jsonSerializerContext, CancellationToken cancellationToken)`
`75`		`- where TCommand : Command`
	`72`	`+ public async Task SendAsync(byte[] data, CancellationToken cancellationToken)`
`76`	`73`	`{`
`77`		`- var buffer = JsonSerializer.SerializeToUtf8Bytes(command, typeof(TCommand), jsonSerializerContext);`
`78`		`-`
`79`	`74`	`await _socketSendSemaphoreSlim.WaitAsync(cancellationToken);`
`80`	`75`
`81`	`76`	`try`
`82`	`77`	`{`
`83`	`78`	`if (_logger.IsEnabled(LogEventLevel.Trace))`
`84`	`79`	`{`
`85`		`- _logger.Trace($"BiDi SND --> {Encoding.UTF8.GetString(buffer)}");`
	`80`	`+ _logger.Trace($"BiDi SND --> {Encoding.UTF8.GetString(data)}");`
`86`	`81`	`}`
`87`	`82`
`88`		`- await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);`
	`83`	`+ await _webSocket.SendAsync(new ArraySegment<byte>(data), WebSocketMessageType.Text, true, cancellationToken).ConfigureAwait(false);`
`89`	`84`	`}`
`90`	`85`	`finally`
`91`	`86`	`{`