Don't wait for Runtime.Evaluate (#690)

* Don't wait for Runtime.Evaluate

* Configure await

* Ops

* codefactor

* Default true on interface

Author: kblok

lib/PuppeteerSharp.Tests/PageTests/ExposeFunctionTests.cs

@@ -81,5 +81,13 @@ await Page.ExposeFunctionAsync("changeFlag", () =>
             await Page.EvaluateExpressionAsync("changeFlag()");
             Assert.True(called);
         }
+
+        [Fact]
+        public async Task ShouldKeepTheCallbackClean()
+        {
+            await Page.ExposeFunctionAsync("compute", (int a, int b) => a * b);
+            var result = await Page.EvaluateExpressionAsync<int>("compute(9, 4)");
+            Assert.False(Page.Client.HasPendingCallbacks());
+        }
     }
 }

lib/PuppeteerSharp/CDPSession.cs

@@ -12,7 +12,7 @@ namespace PuppeteerSharp
 {
     /// <summary>
     /// The CDPSession instances are used to talk raw Chrome Devtools Protocol:
-    ///  * Protocol methods can be called with <see cref="CDPSession.SendAsync(string, dynamic)"/> method.
+    ///  * Protocol methods can be called with <see cref="CDPSession.SendAsync(string, dynamic, bool)"/> method.
     ///  * Protocol events, using the <see cref="CDPSession.MessageReceived"/> event.
     /// 
     /// Documentation on DevTools Protocol can be found here: <see href="https://chromedevtools.github.io/devtools-protocol/"/>.
@@ -95,6 +95,10 @@ internal CDPSession(IConnection connection, TargetType targetType, string sessio
         #endregion
 
         #region Public Methods
+
+        internal void Send(string method, dynamic args = null)
+            => _ = SendAsync(method, args, false);
+
         /// <summary>
         /// Protocol methods can be called with this method.
         /// </summary>
@@ -113,9 +117,13 @@ public async Task<T> SendAsync<T>(string method, dynamic args = null)
         /// </summary>
         /// <param name="method">The method name</param>
         /// <param name="args">The method args</param>
+        /// <param name="waitForCallback">
+        /// If <c>true</c> the method will return a task to be completed when the message is confirmed by Chromium.
+        /// If <c>false</c> the task will be considered complete after sending the message to Chromium.
+        /// </param>
         /// <returns>The task.</returns>
-        /// <exception cref="T:PuppeteerSharp.PuppeteerException"></exception>
-        public async Task<JObject> SendAsync(string method, dynamic args = null)
+        /// <exception cref="PuppeteerSharp.PuppeteerException"></exception>
+        public async Task<JObject> SendAsync(string method, dynamic args = null, bool waitForCallback = true)
         {
             if (Connection == null)
             {
@@ -130,31 +138,37 @@ public async Task<JObject> SendAsync(string method, dynamic args = null)
             });
             _logger.LogTrace("Send ► {Id} Method {Method} Params {@Params}", id, method, (object)args);
 
-            var callback = new MessageTask
+            MessageTask callback = null;
+            if (waitForCallback)
             {
-                TaskWrapper = new TaskCompletionSource<JObject>(),
-                Method = method
-            };
-            _callbacks[id] = callback;
+                callback = new MessageTask
+                {
+                    TaskWrapper = new TaskCompletionSource<JObject>(),
+                    Method = method
+                };
+                _callbacks[id] = callback;
+            }
 
             try
             {
-                await Connection.SendAsync("Target.sendMessageToTarget", new Dictionary<string, object>
-                {
-                    { MessageKeys.SessionId, SessionId },
-                    { MessageKeys.Message, message }
-                }).ConfigureAwait(false);
+                await Connection.SendAsync(
+                    "Target.sendMessageToTarget", new Dictionary<string, object>
+                    {
+                        {"sessionId", SessionId},
+                        {"message", message}
+                    },
+                    waitForCallback).ConfigureAwait(false);
             }
             catch (Exception ex)
             {
-                if (_callbacks.ContainsKey(id))
+                if (waitForCallback && _callbacks.ContainsKey(id))
                 {
                     _callbacks.Remove(id);
                     callback.TaskWrapper.SetException(new MessageException(ex.Message, ex));
                 }
             }
 
-            return await callback.TaskWrapper.Task.ConfigureAwait(false);
+            return waitForCallback ? await callback.TaskWrapper.Task.ConfigureAwait(false) : null;
         }
 
         /// <summary>
@@ -281,7 +295,8 @@ internal CDPSession CreateSession(TargetType targetType, string sessionId)
         #region IConnection
         ILoggerFactory IConnection.LoggerFactory => LoggerFactory;
         bool IConnection.IsClosed => IsClosed;
-        Task<JObject> IConnection.SendAsync(string method, dynamic args) => SendAsync(method, args);
+        Task<JObject> IConnection.SendAsync(string method, dynamic args, bool waitForCallback)
+            => SendAsync(method, args, waitForCallback);
         #endregion
     }
 }

lib/PuppeteerSharp/Connection.cs

@@ -84,7 +84,7 @@ internal Connection(string url, int delay, WebSocket ws, ILoggerFactory loggerFa
 
         #region Public Methods
 
-        internal async Task<JObject> SendAsync(string method, dynamic args = null)
+        internal async Task<JObject> SendAsync(string method, dynamic args = null, bool waitForCallback = true)
         {
             if (IsClosed)
             {
@@ -101,18 +101,23 @@ internal async Task<JObject> SendAsync(string method, dynamic args = null)
 
             _logger.LogTrace("Send ► {Id} Method {Method} Params {@Params}", id, method, (object)args);
 
-            var callback = new MessageTask
+            MessageTask callback = null;
+            if (waitForCallback)
             {
-                TaskWrapper = new TaskCompletionSource<JObject>(),
-                Method = method
-            };
-            _callbacks[id] = callback;
+
+                callback = new MessageTask
+                {
+                    TaskWrapper = new TaskCompletionSource<JObject>(),
+                    Method = method
+                };
+                _callbacks[id] = callback;
+            }
 
             var encoded = Encoding.UTF8.GetBytes(message);
             var buffer = new ArraySegment<byte>(encoded, 0, encoded.Length);
             await _socketQueue.Enqueue(() => WebSocket.SendAsync(buffer, WebSocketMessageType.Text, true, default)).ConfigureAwait(false);
 
-            return await callback.TaskWrapper.Task.ConfigureAwait(false);
+            return waitForCallback ? await callback.TaskWrapper.Task.ConfigureAwait(false) : null;
         }
 
         internal async Task<T> SendAsync<T>(string method, dynamic args = null)
@@ -335,7 +340,8 @@ public void Dispose()
         #region IConnection
         ILoggerFactory IConnection.LoggerFactory => LoggerFactory;
         bool IConnection.IsClosed => IsClosed;
-        Task<JObject> IConnection.SendAsync(string method, dynamic args) => SendAsync(method, args);
+        Task<JObject> IConnection.SendAsync(string method, dynamic args, bool waitForCallback)
+            => SendAsync(method, args, waitForCallback);
         #endregion
     }
 }

lib/PuppeteerSharp/IConnection.cs

@@ -25,6 +25,10 @@ internal interface IConnection
         /// <returns>The async.</returns>
         /// <param name="method">Method to call.</param>
         /// <param name="args">Method arguments.</param>
-        Task<JObject> SendAsync(string method, dynamic args = null);
+        /// <param name="waitForCallback">
+        /// If <c>true</c> the method will return a task to be completed when the message is confirmed by Chromium.
+        /// If <c>false</c> the task will be considered complete after sending the message to Chromium.
+        /// </param>
+        Task<JObject> SendAsync(string method, dynamic args = null, bool waitForCallback = true);
     }
 }

lib/PuppeteerSharp/Page.cs

@@ -1833,7 +1833,7 @@ private async Task OnBindingCalled(BindingCalledResponse e)
                     window[name]['callbacks'].delete(seq);
                 }", e.Payload.Name, e.Payload.Seq, result);
 
-            await Client.SendAsync("Runtime.evaluate", new
+            Client.Send("Runtime.evaluate", new
             {
                 expression,
                 contextId = e.ExecutionContextId