Execute frame.waitFor{Selector,XPath} in secondary world (#936)

Author: kblok

lib/PuppeteerSharp.Tests/FrameTests/WaitForSelectorTests.cs

@@ -24,6 +24,15 @@ public async Task ShouldImmediatelyResolveTaskIfNodeExists()
             await frame.WaitForSelectorAsync("div");
         }
 
+        [Fact]
+        public async Task ShouldWorkWithRemovedMutationObserver()
+        {
+            await Page.EvaluateExpressionAsync("delete window.MutationObserver");
+            var waitForSelector = Page.WaitForSelectorAsync(".zombo");
+            await Page.SetContentAsync("<div class='zombo'>anything</div>");
+            Assert.Equal("anything", await Page.EvaluateFunctionAsync<string>("x => x.textContent", await waitForSelector));
+        }
+
         [Fact]
         public async Task ShouldResolveTaskWhenNodeIsAdded()
         {
@@ -75,17 +84,6 @@ public async Task ShouldRunInSpecifiedFrame()
             Assert.Equal(frame2, eHandle.ExecutionContext.Frame);
         }
 
-        [Fact]
-        public async Task ShouldThrowIfEvaluationFailed()
-        {
-            await Page.EvaluateOnNewDocumentAsync(@"function() {
-                document.querySelector = null;
-            }");
-            await Page.GoToAsync(TestConstants.EmptyPage);
-            var exception = await Assert.ThrowsAnyAsync<PuppeteerException>(() => Page.WaitForSelectorAsync("*"));
-            Assert.Contains("document.querySelector is not a function", exception.Message);
-        }
-
         [Fact]
         public async Task ShouldThrowWhenFrameIsDetached()
         {

lib/PuppeteerSharp.Tests/FrameTests/WaitForXPathTests.cs

@@ -38,18 +38,6 @@ public async Task ShouldRunInSpecifiedFrame()
             Assert.Equal(frame2, eHandle.ExecutionContext.Frame);
         }
 
-        [Fact]
-        public async Task ShouldThrowIfEvaluationFailed()
-        {
-            await Page.EvaluateOnNewDocumentAsync(@"function() {
-                document.evaluate = null;
-            }");
-            await Page.GoToAsync(TestConstants.EmptyPage);
-            var exception = await Assert.ThrowsAsync<EvaluationFailedException>(()
-                => Page.WaitForXPathAsync("*"));
-            Assert.Contains("document.evaluate is not a function", exception.Message);
-        }
-
         [Fact]
         public async Task ShouldThrowWhenFrameIsDetached()
         {

lib/PuppeteerSharp/ExecutionContext.cs

@@ -266,5 +266,30 @@ private static string GetExceptionMessage(EvaluateExceptionResponseDetails excep
             }
             return message;
         }
+
+        internal async Task<ElementHandle> AdoptElementHandleASync(ElementHandle elementHandle)
+        {
+            if (elementHandle.ExecutionContext == this)
+            {
+                throw new PuppeteerException("Cannot adopt handle that already belongs to this execution context");
+            }
+            if (World == null)
+            {
+                throw new PuppeteerException("Cannot adopt handle without DOMWorld");
+            }
+
+            var nodeInfo = await _client.SendAsync<DomDescribeNodeResponse>("DOM.describeNode", new DomDescribeNodeRequest
+            {
+                ObjectId = elementHandle.RemoteObject.ObjectId,
+            }).ConfigureAwait(false);
+
+            var obj = await _client.SendAsync<DomResolveNodeResponse>("DOM.resolveNode", new DomResolveNodeRequest
+            {
+                BackendNodeId = nodeInfo.Node.BackendNodeId,
+                ExecutionContextId = _contextId
+            }).ConfigureAwait(false);
+
+            return CreateJSHandle(obj.Object) as ElementHandle;
+        }
     }
 }

lib/PuppeteerSharp/Frame.cs

@@ -246,8 +246,18 @@ public Task<Response> GoToAsync(string url, int? timeout = null, WaitUntilNaviga
         /// <seealso cref="WaitForXPathAsync(string, WaitForSelectorOptions)"/>
         /// <seealso cref="Page.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>
         /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>
-        public Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)
-            => MainWorld.WaitForSelectorAsync(selector, options);
+        public async Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)
+        {
+            var handle = await SecondaryWorld.WaitForSelectorAsync(selector, options).ConfigureAwait(false);
+            if (handle == null)
+            {
+                return null;
+            }
+            var mainExecutionContext = await MainWorld.GetExecutionContextAsync().ConfigureAwait(false);
+            var result = await mainExecutionContext.AdoptElementHandleASync(handle).ConfigureAwait(false);
+            await handle.DisposeAsync().ConfigureAwait(false);
+            return result;
+        }
 
         /// <summary>
         /// Waits for a selector to be added to the DOM
@@ -277,8 +287,18 @@ public Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelector
         /// <seealso cref="WaitForSelectorAsync(string, WaitForSelectorOptions)"/>
         /// <seealso cref="Page.WaitForXPathAsync(string, WaitForSelectorOptions)"/>
         /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>
-        public Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)
-            => MainWorld.WaitForXPathAsync(xpath, options);
+        public async Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)
+        {
+            var handle = await SecondaryWorld.WaitForXPathAsync(xpath, options).ConfigureAwait(false);
+            if (handle == null)
+            {
+                return null;
+            }
+            var mainExecutionContext = await MainWorld.GetExecutionContextAsync().ConfigureAwait(false);
+            var result = await mainExecutionContext.AdoptElementHandleASync(handle).ConfigureAwait(false);
+            await handle.DisposeAsync().ConfigureAwait(false);
+            return result;
+        }
 
         /// <summary>
         /// Waits for a timeout

lib/PuppeteerSharp/Messaging/DomDescribeNodeResponse.cs

@@ -7,6 +7,7 @@ internal class DomDescribeNodeResponse
         internal class DomNode
         {
             public string FrameId { get; set; }
+            public int BackendNodeId { get; set; }
         }
     }
 }

lib/PuppeteerSharp/Messaging/DomResolveNodeRequest.cs

@@ -0,0 +1,8 @@
+namespace PuppeteerSharp.Messaging
+{
+    internal class DomResolveNodeRequest
+    {
+        public int BackendNodeId { get; set; }
+        public int ExecutionContextId { get; set; }
+    }
+}

lib/PuppeteerSharp/Messaging/DomResolveNodeResponse.cs

@@ -0,0 +1,7 @@
+namespace PuppeteerSharp.Messaging
+{
+    internal class DomResolveNodeResponse
+    {
+        public RemoteObject Object { get; set; }
+    }
+}

lib/PuppeteerSharp/Page.cs

@@ -1549,12 +1549,14 @@ await Task.WhenAll(
                     Enabled = true
                 }),
                 client.SendAsync("Network.enable", null),
-                client.SendAsync("Runtime.enable", null).ContinueWith(t => page.FrameManager.EnsureSecondaryDOMWorldAsync()),
+                client.SendAsync("Runtime.enable", null),
                 client.SendAsync("Security.enable", null),
                 client.SendAsync("Performance.enable", null),
                 client.SendAsync("Log.enable", null)
             ).ConfigureAwait(false);
 
+            await page.FrameManager.EnsureSecondaryDOMWorldAsync().ConfigureAwait(false);
+
             if (ignoreHTTPSErrors)
             {
                 await client.SendAsync("Security.setOverrideCertificateErrors", new SecuritySetOverrideCertificateErrorsRequest

lib/PuppeteerSharp/WaitTask.cs

@@ -194,6 +194,7 @@ await _world.EvaluateFunctionAsync<bool>("s => !s", success)
 
             if (exception?.Message.Contains("Execution context was destroyed") == true)
             {
+                _ = Rerun();
                 return;
             }