Support waitUntil option for Page.SetContentAsync (#788)

Author: Meir017

lib/PuppeteerSharp.Tests/PageTests/SetContentTests.cs

@@ -44,5 +44,21 @@ public async Task ShouldWorkWithHtml4Doctype()
 
             Assert.Equal($"{doctype}{ExpectedOutput}", result);
         }
+
+        [Fact]
+        public async Task ShouldAwaitResourceToLoad()
+        {
+            var imgPath = "/img.png";
+            var imgResponse = new TaskCompletionSource<bool>();
+            Server.SetRoute(imgPath, context => imgResponse.Task);
+            var loaded = false;
+            var waitTask = Server.WaitForRequest(imgPath);
+            var contentTask = Page.SetContentAsync($"<img src=\"{TestConstants.ServerUrl + imgPath}\"></img>")
+                .ContinueWith(_ => loaded = true);
+            await waitTask;
+            Assert.False(loaded);
+            imgResponse.SetResult(true);
+            await contentTask;
+        }
     }
 }

lib/PuppeteerSharp/Browser.cs

@@ -152,7 +152,7 @@ public Browser(
         /// <summary>
         /// Dafault wait time in milliseconds. Defaults to 30 seconds.
         /// </summary>
-        public int DefaultWaitForTimeout { get; set; } = 30000;
+        public int DefaultWaitForTimeout { get; set; } = Puppeteer.DefaultTimeout;
 
         #endregion
 

lib/PuppeteerSharp/CookieParam.cs

@@ -5,7 +5,7 @@ namespace PuppeteerSharp
     /// <summary>
     /// Cookie data.
     /// </summary>
-    /// <seealso cref="Page.SetContentAsync(string)"/>
+    /// <seealso cref="Page.SetContentAsync(string, NavigationOptions)"/>
     /// <seealso cref="Page.DeleteCookieAsync(CookieParam[])"/>
     /// <seealso cref="Page.GetCookiesAsync(string[])"/>
     public class CookieParam

lib/PuppeteerSharp/Frame.cs

@@ -544,21 +544,37 @@ public Task<string> GetContentAsync()
                 if (document.documentElement)
                     retVal += document.documentElement.outerHTML;
                 return retVal;
-            }");
-
+            }");
+
         /// <summary>
         /// Sets the HTML markup to the page
         /// </summary>
-        /// <param name="html">HTML markup to assign to the page.</param>
+        /// <param name="html">HTML markup to assign to the page.</param>
+        /// <param name="options">The options</param>
         /// <returns>Task.</returns>
-        /// <seealso cref="Page.SetContentAsync(string)"/>
-        public Task SetContentAsync(string html)
-            => EvaluateFunctionAsync(@"html => {
+        /// <seealso cref="Page.SetContentAsync(string, NavigationOptions)"/>
+        public async Task SetContentAsync(string html, NavigationOptions options = null)
+        {
+            var waitUntil = options?.WaitUntil ?? new[] { WaitUntilNavigation.Load };
+            var timeout = options?.Timeout ?? Puppeteer.DefaultTimeout;
+
+            // We rely upon the fact that document.open() will reset frame lifecycle with "init"
+            // lifecycle event. @see https://crrev.com/608658
+            await EvaluateFunctionAsync(@"html => {
                 document.open();
                 document.write(html);
                 document.close();
-            }", html);
+            }", html);
+
+            var watcher = new LifecycleWatcher(FrameManager, this, timeout, options);
+
+            var watcherTask = await Task.WhenAny(
+                watcher.TimeoutOrTerminationTask,
+                watcher.LifecycleTask).ConfigureAwait(false);
 
+            await watcherTask;
+        }
+
         /// <summary>
         /// Returns page's title
         /// </summary>

lib/PuppeteerSharp/FrameManager.cs

@@ -11,27 +11,25 @@
 namespace PuppeteerSharp
 {
     internal class FrameManager
-    {
-        private readonly CDPSession _client;
+    {        
         private Dictionary<int, ExecutionContext> _contextIdToContext;
         private bool _ensureNewDocumentNavigation;
-        private readonly ILogger _logger;
-        private readonly NetworkManager _networkManager;
+        private readonly ILogger _logger;        
         private readonly ConcurrentDictionary<string, Frame> _frames;
         private readonly MultiMap<string, TaskCompletionSource<Frame>> _pendingFrameRequests;
         private const int WaitForRequestDelay = 1000;
 
         private FrameManager(CDPSession client, Page page, NetworkManager networkManager)
         {
-            _client = client;
+            Client = client;
             Page = page;
             _frames = new ConcurrentDictionary<string, Frame>();
             _contextIdToContext = new Dictionary<int, ExecutionContext>();
-            _logger = _client.Connection.LoggerFactory.CreateLogger<FrameManager>();
-            _networkManager = networkManager;
+            _logger = Client.Connection.LoggerFactory.CreateLogger<FrameManager>();
+            NetworkManager = networkManager;
             _pendingFrameRequests = new MultiMap<string, TaskCompletionSource<Frame>>();
 
-            _client.MessageReceived += Client_MessageReceived;
+            Client.MessageReceived += Client_MessageReceived;
         }
 
         #region Properties
@@ -42,6 +40,8 @@ private FrameManager(CDPSession client, Page page, NetworkManager networkManager
         internal event EventHandler<FrameEventArgs> FrameNavigatedWithinDocument;
         internal event EventHandler<FrameEventArgs> LifecycleEvent;
 
+        internal CDPSession Client { get; }
+        internal NetworkManager NetworkManager { get; }
         internal Frame MainFrame { get; set; }
         internal Page Page { get; }
         internal int DefaultNavigationTimeout { get; set; } = 30000;
@@ -70,13 +70,13 @@ internal ExecutionContext ExecutionContextById(int contextId)
         public async Task<Response> NavigateFrameAsync(Frame frame, string url, NavigationOptions options)
         {
             var referrer = string.IsNullOrEmpty(options.Referer)
-               ? _networkManager.ExtraHTTPHeaders?.GetValueOrDefault(MessageKeys.Referer)
+               ? NetworkManager.ExtraHTTPHeaders?.GetValueOrDefault(MessageKeys.Referer)
                : options.Referer;
             var requests = new Dictionary<string, Request>();
             var timeout = options?.Timeout ?? DefaultNavigationTimeout;
-            using (var watcher = new NavigatorWatcher(_client, this, frame, _networkManager, timeout, options))
+            using (var watcher = new LifecycleWatcher(this, frame, timeout, options))
             {
-                var navigateTask = NavigateAsync(_client, url, referrer, frame.Id);
+                var navigateTask = NavigateAsync(Client, url, referrer, frame.Id);
                 await Task.WhenAny(
                     watcher.TimeoutOrTerminationTask,
                     navigateTask).ConfigureAwait(false);
@@ -128,7 +128,7 @@ private async Task NavigateAsync(CDPSession client, string url, string referrer,
         public async Task<Response> WaitForFrameNavigationAsync(Frame frame, NavigationOptions options = null)
         {
             var timeout = options?.Timeout ?? DefaultNavigationTimeout;
-            using (var watcher = new NavigatorWatcher(_client, this, frame, _networkManager, timeout, options))
+            using (var watcher = new LifecycleWatcher(this, frame, timeout, options))
             {
                 var raceTask = await Task.WhenAny(
                     watcher.NewDocumentNavigationTask,
@@ -205,7 +205,7 @@ private async void Client_MessageReceived(object sender, MessageEventArgs e)
             {
                 var message = $"Connection failed to process {e.MessageID}. {ex.Message}. {ex.StackTrace}";
                 _logger.LogError(ex, message);
-                _client.Close(message);
+                Client.Close(message);
             }
         }
 
@@ -254,7 +254,7 @@ private async Task OnExecutionContextCreatedAsync(ContextPayload contextPayload)
             var frame = !string.IsNullOrEmpty(frameId) ? await GetFrameAsync(frameId) : null;
 
             var context = new ExecutionContext(
-                _client,
+                Client,
                 contextPayload,
                 frame);
 
@@ -305,7 +305,7 @@ private async Task OnFrameNavigatedAsync(FramePayload framePayload)
                 else
                 {
                     // Initial main frame navigation.
-                    frame = new Frame(this, _client, null, framePayload.Id);
+                    frame = new Frame(this, Client, null, framePayload.Id);
                 }
                 AddFrame(framePayload.Id, frame);
                 MainFrame = frame;
@@ -364,7 +364,7 @@ private void OnFrameAttached(string frameId, string parentFrameId)
             if (!_frames.ContainsKey(frameId) && _frames.ContainsKey(parentFrameId))
             {
                 var parentFrame = _frames[parentFrameId];
-                var frame = new Frame(this, _client, parentFrame, frameId);
+                var frame = new Frame(this, Client, parentFrame, frameId);
                 _frames[frame.Id] = frame;
                 FrameAttached?.Invoke(this, new FrameEventArgs(frame));
             }

lib/PuppeteerSharp/LaunchOptions.cs

@@ -42,7 +42,7 @@ public class LaunchOptions : IBrowserOptions, IConnectionOptions
         /// <summary>
         /// Maximum time in milliseconds to wait for the browser instance to start. Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
         /// </summary>
-        public int Timeout { get; set; } = 30_000;
+        public int Timeout { get; set; } = Puppeteer.DefaultTimeout;
 
         /// <summary>
         ///  Whether to pipe browser process stdout and stderr into process.stdout and process.stderr. Defaults to false.