How to use FrameManager class of PuppeteerSharp package

...219        /// </summary>220        /// <remarks>221        /// Page is guaranteed to have a main frame which persists during navigations.222        /// </remarks>223        public Frame MainFrame => FrameManager.MainFrame;224        /// <summary>225        /// Gets all frames attached to the page.226        /// </summary>227        /// <value>An array of all frames attached to the page.</value>228        public Frame[] Frames => FrameManager.GetFrames();229        ///// <summary>230        ///// Gets all workers in the page.231        ///// </summary>232        //public Worker[] Workers => _workers.Values.ToArray();233        /// <summary>234        /// Shortcut for <c>page.MainFrame.Url</c>235        /// </summary>236        public string Url => MainFrame.Url;237        /// <summary>238        /// Gets that target this page was created from.239        /// </summary>240        public Target Target { get; }241        /// <summary>242        /// Gets this page's keyboard243        /// </summary>244        public Keyboard Keyboard { get; }245        /// <summary>246        /// Gets this page's touchscreen247        /// </summary>248        public Touchscreen Touchscreen { get; }249        /// <summary>250        /// Gets this page's coverage251        /// </summary>252        public Coverage Coverage { get; }253        /// <summary>254        /// Gets this page's mouse255        /// </summary>256        public Mouse Mouse { get; }257        /// <summary>258        /// Gets this page's viewport259        /// </summary>260        public ViewPortOptions Viewport { get; private set; }261        /// <summary>262        /// List of supported metrics provided by the <see cref="Metrics"/> event.263        /// </summary>264        public static readonly IEnumerable<string> SupportedMetrics = new List<string>265        {266            "Timestamp",267            "Documents",268            "Frames",269            "JSEventListeners",270            "Nodes",271            "LayoutCount",272            "RecalcStyleCount",273            "LayoutDuration",274            "RecalcStyleDuration",275            "ScriptDuration",276            "TaskDuration",277            "JSHeapUsedSize",278            "JSHeapTotalSize"279        };280        /// <summary>281        /// Get the browser the page belongs to.282        /// </summary>283        public Browser Browser => Target.Browser;284        /// <summary>285        /// Get the browser context that the page belongs to.286        /// </summary>287        public BrowserContext BrowserContext => Target.BrowserContext;288        /// <summary>289        /// Get an indication that the page has been closed.290        /// </summary>291        public bool IsClosed { get; private set; }292        /// <summary>293        /// Gets the accessibility.294        /// </summary>295        public Accessibility Accessibility { get; }296        internal bool JavascriptEnabled { get; set; } = true;297        internal bool HasPopupEventListeners => Popup?.GetInvocationList().Any() == true;298        internal FrameManager FrameManager { get; private set; }299        private Task SessionClosedTask300        {301            get302            {303                if (_sessionClosedTcs == null)304                {305                    _sessionClosedTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);306                    Client.Disconnected += clientDisconnected;307                    void clientDisconnected(object sender, EventArgs e)308                    {309                        _sessionClosedTcs.TrySetException(new TargetClosedException("Target closed", "Session closed"));310                        Client.Disconnected -= clientDisconnected;311                    }312                }313                return _sessionClosedTcs.Task;314            }315        }316        #endregion317        #region Public Methods318        /// <summary>319        /// A utility function to be used with <see cref="Extensions.EvaluateFunctionAsync{T}(Task{JSHandle}, string, object[])"/>320        /// </summary>321        /// <param name="selector">A selector to query page for</param>322        /// <returns>Task which resolves to a <see cref="JSHandle"/> of <c>document.querySelectorAll</c> result</returns>323        public Task<JSHandle> QuerySelectorAllHandleAsync(string selector)324            => EvaluateFunctionHandleAsync("selector => Array.from(document.querySelectorAll(selector))", selector);325        /// <summary>326        /// Executes a script in browser context327        /// </summary>328        /// <param name="script">Script to be evaluated in browser context</param>329        /// <remarks>330        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.331        /// </remarks>332        /// <returns>Task which resolves to script return value</returns>333        public async Task<JSHandle> EvaluateExpressionHandleAsync(string script)334        {335            var context = await MainFrame.GetExecutionContextAsync().ConfigureAwait(false);336            return await context.EvaluateExpressionHandleAsync(script).ConfigureAwait(false);337        }338        /// <summary>339        /// Executes a script in browser context340        /// </summary>341        /// <param name="pageFunction">Script to be evaluated in browser context</param>342        /// <param name="args">Function arguments</param>343        /// <remarks>344        /// If the script, returns a Promise, then the method would wait for the promise to resolve and return its value.345        /// <see cref="JSHandle"/> instances can be passed as arguments346        /// </remarks>347        /// <returns>Task which resolves to script return value</returns>348        public async Task<JSHandle> EvaluateFunctionHandleAsync(string pageFunction, params object[] args)349        {350            var context = await MainFrame.GetExecutionContextAsync().ConfigureAwait(false);351            return await context.EvaluateFunctionHandleAsync(pageFunction, args).ConfigureAwait(false);352        }353        /// <summary>354        /// Activating request interception enables <see cref="Request.AbortAsync(RequestAbortErrorCode)">request.AbortAsync</see>, 355        /// <see cref="Request.ContinueAsync(Payload)">request.ContinueAsync</see> and <see cref="Request.RespondAsync(ResponseData)">request.RespondAsync</see> methods.356        /// </summary>357        /// <returns>The request interception task.</returns>358        /// <param name="value">Whether to enable request interception..</param>359        public Task SetRequestInterceptionAsync(bool value)360            => FrameManager.NetworkManager.SetRequestInterceptionAsync(value);361        /// <summary>362        /// Set offline mode for the page.363        /// </summary>364        /// <returns>Result task</returns>365        /// <param name="value">When <c>true</c> enables offline mode for the page.</param>366        public Task SetOfflineModeAsync(bool value) => FrameManager.NetworkManager.SetOfflineModeAsync(value);367        /// <summary>368        /// Adds a <c><![CDATA[<script>]]></c> tag into the page with the desired url or content369        /// </summary>370        /// <param name="options">add script tag options</param>371        /// <remarks>372        /// Shortcut for <c>page.MainFrame.AddScriptTagAsync(options)</c>373        /// </remarks>374        /// <returns>Task which resolves to the added tag when the script's onload fires or when the script content was injected into frame</returns>375        /// <seealso cref="Frame.AddScriptTagAsync(AddTagOptions)"/>376        public Task<ElementHandle> AddScriptTagAsync(AddTagOptions options) => MainFrame.AddScriptTagAsync(options);377        /// <summary>378        /// Adds a <c><![CDATA[<script>]]></c> tag into the page with the desired url or content379        /// </summary>380        /// <param name="url">script url</param>381        /// <remarks>382        /// Shortcut for <c>page.MainFrame.AddScriptTagAsync(new AddTagOptions { Url = url })</c>383        /// </remarks>384        /// <returns>Task which resolves to the added tag when the script's onload fires or when the script content was injected into frame</returns>385        public Task<ElementHandle> AddScriptTagAsync(string url) => AddScriptTagAsync(new AddTagOptions { Url = url });386        /// <summary>387        /// Adds a <c><![CDATA[<link rel="stylesheet">]]></c> tag into the page with the desired url or a <c><![CDATA[<link rel="stylesheet">]]></c> tag with the content388        /// </summary>389        /// <param name="options">add style tag options</param>390        /// <remarks>391        /// Shortcut for <c>page.MainFrame.AddStyleTagAsync(options)</c>392        /// </remarks>393        /// <returns>Task which resolves to the added tag when the stylesheet's onload fires or when the CSS content was injected into frame</returns>394        /// <seealso cref="Frame.AddStyleTag(AddTagOptions)"/>395        public Task<ElementHandle> AddStyleTagAsync(AddTagOptions options) => MainFrame.AddStyleTagAsync(options);396        /// <summary>397        /// Adds a <c><![CDATA[<link rel="stylesheet">]]></c> tag into the page with the desired url or a <c><![CDATA[<link rel="stylesheet">]]></c> tag with the content398        /// </summary>399        /// <param name="url">stylesheel url</param>400        /// <remarks>401        /// Shortcut for <c>page.MainFrame.AddStyleTagAsync(new AddTagOptions { Url = url })</c>402        /// </remarks>403        /// <returns>Task which resolves to the added tag when the stylesheet's onload fires or when the CSS content was injected into frame</returns>404        public Task<ElementHandle> AddStyleTagAsync(string url) => AddStyleTagAsync(new AddTagOptions { Url = url });405        /// <summary>406        /// Adds a function called <c>name</c> on the page's <c>window</c> object.407        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves when <paramref name="puppeteerFunction"/> completes.408        /// </summary>409        /// <param name="name">Name of the function on the window object</param>410        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>411        /// <remarks>412        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.413        /// Functions installed via <see cref="ExposeFunctionAsync(string, Action)"/> survive navigations414        /// </remarks>415        /// <returns>Task</returns>416        public Task ExposeFunctionAsync(string name, Action puppeteerFunction)417            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);418        /// <summary>419        /// Adds a function called <c>name</c> on the page's <c>window</c> object.420        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.421        /// </summary>422        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>423        /// <param name="name">Name of the function on the window object</param>424        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>425        /// <remarks>426        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.427        /// Functions installed via <see cref="ExposeFunctionAsync{TResult}(string, Func{TResult})"/> survive navigations428        /// </remarks>429        /// <returns>Task</returns>430        public Task ExposeFunctionAsync<TResult>(string name, Func<TResult> puppeteerFunction)431            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);432        /// <summary>433        /// Adds a function called <c>name</c> on the page's <c>window</c> object.434        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.435        /// </summary>436        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>437        /// <typeparam name="T">The parameter of <paramref name="puppeteerFunction"/></typeparam>438        /// <param name="name">Name of the function on the window object</param>439        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>440        /// <remarks>441        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.442        /// Functions installed via <see cref="ExposeFunctionAsync{T, TResult}(string, Func{T, TResult})"/> survive navigations443        /// </remarks>444        /// <returns>Task</returns>445        public Task ExposeFunctionAsync<T, TResult>(string name, Func<T, TResult> puppeteerFunction)446            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);447        /// <summary>448        /// Adds a function called <c>name</c> on the page's <c>window</c> object.449        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.450        /// </summary>451        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>452        /// <typeparam name="T1">The first parameter of <paramref name="puppeteerFunction"/></typeparam>453        /// <typeparam name="T2">The second parameter of <paramref name="puppeteerFunction"/></typeparam>454        /// <param name="name">Name of the function on the window object</param>455        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>456        /// <remarks>457        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.458        /// Functions installed via <see cref="ExposeFunctionAsync{T1, T2, TResult}(string, Func{T1, T2, TResult})"/> survive navigations459        /// </remarks>460        /// <returns>Task</returns>461        public Task ExposeFunctionAsync<T1, T2, TResult>(string name, Func<T1, T2, TResult> puppeteerFunction)462            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);463        /// <summary>464        /// Adds a function called <c>name</c> on the page's <c>window</c> object.465        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.466        /// </summary>467        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>468        /// <typeparam name="T1">The first parameter of <paramref name="puppeteerFunction"/></typeparam>469        /// <typeparam name="T2">The second parameter of <paramref name="puppeteerFunction"/></typeparam>470        /// <typeparam name="T3">The third parameter of <paramref name="puppeteerFunction"/></typeparam>471        /// <param name="name">Name of the function on the window object</param>472        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>473        /// <remarks>474        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.475        /// Functions installed via <see cref="ExposeFunctionAsync{T1, T2, T3, TResult}(string, Func{T1, T2, T3, TResult})"/> survive navigations476        /// </remarks>477        /// <returns>Task</returns>478        public Task ExposeFunctionAsync<T1, T2, T3, TResult>(string name, Func<T1, T2, T3, TResult> puppeteerFunction)479            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);480        /// <summary>481        /// Adds a function called <c>name</c> on the page's <c>window</c> object.482        /// When called, the function executes <paramref name="puppeteerFunction"/> in C# and returns a <see cref="Task"/> which resolves to the return value of <paramref name="puppeteerFunction"/>.483        /// </summary>484        /// <typeparam name="TResult">The result of <paramref name="puppeteerFunction"/></typeparam>485        /// <typeparam name="T1">The first parameter of <paramref name="puppeteerFunction"/></typeparam>486        /// <typeparam name="T2">The second parameter of <paramref name="puppeteerFunction"/></typeparam>487        /// <typeparam name="T3">The third parameter of <paramref name="puppeteerFunction"/></typeparam>488        /// <typeparam name="T4">The fourth parameter of <paramref name="puppeteerFunction"/></typeparam>489        /// <param name="name">Name of the function on the window object</param>490        /// <param name="puppeteerFunction">Callback function which will be called in Puppeteer's context.</param>491        /// <remarks>492        /// If the <paramref name="puppeteerFunction"/> returns a <see cref="Task"/>, it will be awaited.493        /// Functions installed via <see cref="ExposeFunctionAsync{T1, T2, T3, T4, TResult}(string, Func{T1, T2, T3, T4, TResult})"/> survive navigations494        /// </remarks>495        /// <returns>Task</returns>496        public Task ExposeFunctionAsync<T1, T2, T3, T4, TResult>(string name, Func<T1, T2, T3, T4, TResult> puppeteerFunction)497            => ExposeFunctionAsync(name, (Delegate)puppeteerFunction);498        /// <summary>499        /// Gets the full HTML contents of the page, including the doctype.500        /// </summary>501        /// <returns>Task which resolves to the HTML content.</returns>502        /// <seealso cref="Frame.GetContentAsync"/>503        public Task<string> GetContentAsync() => FrameManager.MainFrame.GetContentAsync();504        /// <summary>505        /// Sets the HTML markup to the page506        /// </summary>507        /// <param name="html">HTML markup to assign to the page.</param>508        /// <param name="options">The navigations options</param>509        /// <returns>Task.</returns>510        /// <seealso cref="Frame.SetContentAsync(string, NavigationOptions)"/>511        public Task SetContentAsync(string html, NavigationOptions options = null) => FrameManager.MainFrame.SetContentAsync(html, options);512        /// <summary>513        /// Navigates to an url514        /// </summary>515        /// <remarks>516        /// <see cref="GoToAsync(string, int?, WaitUntilNavigation[])"/> will throw an error if:517        /// - there's an SSL error (e.g. in case of self-signed certificates).518        /// - target URL is invalid.519        /// - the `timeout` is exceeded during navigation.520        /// - the remote server does not respond or is unreachable.521        /// - the main resource failed to load.522        /// 523        /// <see cref="GoToAsync(string, int?, WaitUntilNavigation[])"/> will not throw an error when any valid HTTP status code is returned by the remote server, 524        /// including 404 "Not Found" and 500 "Internal Server Error".  The status code for such responses can be retrieved by calling <see cref="Response.Status"/>525        /// 526        /// > **NOTE** <see cref="GoToAsync(string, int?, WaitUntilNavigation[])"/> either throws an error or returns a main resource response. 527        /// The only exceptions are navigation to `about:blank` or navigation to the same URL with a different hash, which would succeed and return `null`.528        /// 529        /// > **NOTE** Headless mode doesn't support navigation to a PDF document. See the <see fref="https://bugs.chromium.org/p/chromium/issues/detail?id=761295">upstream issue</see>.530        /// 531        /// Shortcut for <seealso cref="Frame.GoToAsync(string, int?, WaitUntilNavigation[])"/>532        /// </remarks>533        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>534        /// <param name="options">Navigation parameters.</param>535        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect.</returns>536        /// <seealso cref="GoToAsync(string, int?, WaitUntilNavigation[])"/>537        public Task<Response> GoToAsync(string url, NavigationOptions options) => FrameManager.MainFrame.GoToAsync(url, options);538        /// <summary>539        /// Navigates to an url540        /// </summary>541        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>542        /// <param name="timeout">Maximum navigation time in milliseconds, defaults to 30 seconds, pass <c>0</c> to disable timeout. </param>543        /// <param name="waitUntil">When to consider navigation succeeded, defaults to <see cref="WaitUntilNavigation.Load"/>. Given an array of <see cref="WaitUntilNavigation"/>, navigation is considered to be successful after all events have been fired</param>544        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>545        /// <seealso cref="GoToAsync(string, NavigationOptions)"/>546        public Task<Response> GoToAsync(string url, int? timeout = null, WaitUntilNavigation[] waitUntil = null)547            => GoToAsync(url, new NavigationOptions { Timeout = timeout, WaitUntil = waitUntil });548        /// <summary>549        /// Navigates to an url550        /// </summary>551        /// <param name="url">URL to navigate page to. The url should include scheme, e.g. https://.</param>552        /// <param name="waitUntil">When to consider navigation succeeded.</param>553        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>554        /// <seealso cref="GoToAsync(string, NavigationOptions)"/>555        public Task<Response> GoToAsync(string url, WaitUntilNavigation waitUntil)556            => GoToAsync(url, new NavigationOptions { WaitUntil = new[] { waitUntil } });557        /// <summary>558        /// generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>559        /// </summary>560        /// <param name="file">The file path to save the PDF to. paths are resolved using <see cref="Path.GetFullPath(string)"/></param>561        /// <returns></returns>562        /// <remarks>563        /// Generating a pdf is currently only supported in Chrome headless564        /// </remarks>565        public Task PdfAsync(string file) => PdfAsync(file, new PdfOptions());566        /// <summary>567        ///  generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>568        /// </summary>569        /// <param name="file">The file path to save the PDF to. paths are resolved using <see cref="Path.GetFullPath(string)"/></param>570        /// <param name="options">pdf options</param>571        /// <returns></returns>572        /// <remarks>573        /// Generating a pdf is currently only supported in Chrome headless574        /// </remarks>575        public async Task PdfAsync(string file, PdfOptions options)576            => await PdfInternalAsync(file, options).ConfigureAwait(false);577        /// <summary>578        /// generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>579        /// </summary>580        /// <returns>Task which resolves to a <see cref="Stream"/> containing the PDF data.</returns>581        /// <remarks>582        /// Generating a pdf is currently only supported in Chrome headless583        /// </remarks>584        public Task<Stream> PdfStreamAsync() => PdfStreamAsync(new PdfOptions());585        /// <summary>586        /// Generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>587        /// </summary>588        /// <param name="options">pdf options</param>589        /// <returns>Task which resolves to a <see cref="Stream"/> containing the PDF data.</returns>590        /// <remarks>591        /// Generating a pdf is currently only supported in Chrome headless592        /// </remarks>593        public async Task<Stream> PdfStreamAsync(PdfOptions options)594            => new MemoryStream(await PdfDataAsync(options).ConfigureAwait(false));595        /// <summary>596        /// Generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>597        /// </summary>598        /// <returns>Task which resolves to a <see cref="byte"/>[] containing the PDF data.</returns>599        /// <remarks>600        /// Generating a pdf is currently only supported in Chrome headless601        /// </remarks>602        public Task<byte[]> PdfDataAsync() => PdfDataAsync(new PdfOptions());603        /// <summary>604        /// Generates a pdf of the page with <see cref="MediaType.Print"/> css media. To generate a pdf with <see cref="MediaType.Screen"/> media call <see cref="EmulateMediaAsync(MediaType)"/> with <see cref="MediaType.Screen"/>605        /// </summary>606        /// <param name="options">pdf options</param>607        /// <returns>Task which resolves to a <see cref="byte"/>[] containing the PDF data.</returns>608        /// <remarks>609        /// Generating a pdf is currently only supported in Chrome headless610        /// </remarks>611        public Task<byte[]> PdfDataAsync(PdfOptions options) => PdfInternalAsync(null, options);612        internal async Task<byte[]> PdfInternalAsync(string file, PdfOptions options)613        {614            var paperWidth = PaperFormat.Letter.Width;615            var paperHeight = PaperFormat.Letter.Height;616            if (options.Format != null)617            {618                paperWidth = options.Format.Width;619                paperHeight = options.Format.Height;620            }621            else622            {623                if (options.Width != null)624                {625                    paperWidth = ConvertPrintParameterToInches(options.Width);626                }627                if (options.Height != null)628                {629                    paperHeight = ConvertPrintParameterToInches(options.Height);630                }631            }632            var marginTop = ConvertPrintParameterToInches(options.MarginOptions.Top);633            var marginLeft = ConvertPrintParameterToInches(options.MarginOptions.Left);634            var marginBottom = ConvertPrintParameterToInches(options.MarginOptions.Bottom);635            var marginRight = ConvertPrintParameterToInches(options.MarginOptions.Right);636            var result = await Client.SendAsync<PagePrintToPDFResponse>("Page.printToPDF", new PagePrintToPDFRequest637            {638                TransferMode = "ReturnAsStream",639                Landscape = options.Landscape,640                DisplayHeaderFooter = options.DisplayHeaderFooter,641                HeaderTemplate = options.HeaderTemplate,642                FooterTemplate = options.FooterTemplate,643                PrintBackground = options.PrintBackground,644                Scale = options.Scale,645                PaperWidth = paperWidth,646                PaperHeight = paperHeight,647                MarginTop = marginTop,648                MarginBottom = marginBottom,649                MarginLeft = marginLeft,650                MarginRight = marginRight,651                PageRanges = options.PageRanges,652                PreferCSSPageSize = options.PreferCSSPageSize653            }).ConfigureAwait(false);654            return await ProtocolStreamReader.ReadProtocolStreamByteAsync(Client, result.Stream, file).ConfigureAwait(false);655        }656        /// <summary>657        /// Enables/Disables Javascript on the page658        /// </summary>659        /// <returns>Task.</returns>660        /// <param name="enabled">Whether or not to enable JavaScript on the page.</param>661        public Task SetJavaScriptEnabledAsync(bool enabled)662        {663            if (enabled == JavascriptEnabled)664            {665                return Task.CompletedTask;666            }667            JavascriptEnabled = enabled;668            return Client.SendAsync("Emulation.setScriptExecutionDisabled", new EmulationSetScriptExecutionDisabledRequest669            {670                Value = !enabled671            });672        }673        /// <summary>674        /// Toggles bypassing page's Content-Security-Policy.675        /// </summary>676        /// <param name="enabled">sets bypassing of page's Content-Security-Policy.</param>677        /// <returns></returns>678        /// <remarks>679        /// CSP bypassing happens at the moment of CSP initialization rather then evaluation.680        /// Usually this means that <see cref="SetBypassCSPAsync(bool)"/> should be called before navigating to the domain.681        /// </remarks>682        public Task SetBypassCSPAsync(bool enabled) => Client.SendAsync("Page.setBypassCSP", new PageSetBypassCSPRequest683        {684            Enabled = enabled685        });686        /// <summary>687        /// Emulates a media such as screen or print.688        /// </summary>689        /// <returns>Task.</returns>690        /// <param name="media">Media to set.</param>691        [Obsolete("User EmulateMediaTypeAsync instead")]692        public Task EmulateMediaAsync(MediaType media) => EmulateMediaTypeAsync(media);693        /// <summary>694        /// Emulates a media such as screen or print.695        /// </summary>696        /// <param name="type">Media to set.</param>697        /// <example>698        /// <code>699        /// <![CDATA[700        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('screen').matches)");701        /// // → true702        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('print').matches)");703        /// // → true704        /// await page.EmulateMediaTypeAsync(MediaType.Print);705        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('screen').matches)");706        /// // → false707        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('print').matches)");708        /// // → true709        /// await page.EmulateMediaTypeAsync(MediaType.None);710        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('screen').matches)");711        /// // → true712        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('print').matches)");713        /// // → true714        /// ]]>715        /// </code>716        /// </example>717        /// <returns>Emulate media type task.</returns>718        public Task EmulateMediaTypeAsync(MediaType type)719            => Client.SendAsync("Emulation.setEmulatedMedia", new EmulationSetEmulatedMediaTypeRequest { Media = type });720        /// <summary>721        /// Given an array of media feature objects, emulates CSS media features on the page.722        /// </summary>723        /// <param name="features">Features to apply</param>724        /// <example>725        /// <code>726        /// <![CDATA[727        /// await page.EmulateMediaFeaturesAsync(new MediaFeature[]{ new MediaFeature { MediaFeature =  MediaFeature.PrefersColorScheme, Value = "dark" }});728        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: dark)').matches)");729        /// // → true730        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: light)').matches)");731        /// // → false732        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");733        /// // → false734        /// await page.EmulateMediaFeaturesAsync(new MediaFeature[]{ new MediaFeature { MediaFeature = MediaFeature.PrefersReducedMotion, Value = "reduce" }});735        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-reduced-motion: reduce)').matches)");736        /// // → true737        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");738        /// // → false739        /// await page.EmulateMediaFeaturesAsync(new MediaFeature[]740        /// { 741        ///   new MediaFeature { MediaFeature = MediaFeature.PrefersColorScheme, Value = "dark" },742        ///   new MediaFeature { MediaFeature = MediaFeature.PrefersReducedMotion, Value = "reduce" },743        /// });744        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: dark)').matches)");745        /// // → true746        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: light)').matches)");747        /// // → false748        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");749        /// // → false750        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-reduced-motion: reduce)').matches)");751        /// // → true752        /// await page.EvaluateFunctionAsync<bool>("() => matchMedia('(prefers-color-scheme: no-preference)').matches)");753        /// // → false754        /// ]]>755        /// </code>756        /// </example>757        /// <returns>Emulate features task</returns>758        public Task EmulateMediaFeaturesAsync(IEnumerable<MediaFeatureValue> features)759            => Client.SendAsync("Emulation.setEmulatedMedia", new EmulationSetEmulatedMediaFeatureRequest { Features = features });760        /// <summary>761        /// Sets the viewport.762        /// In the case of multiple pages in a single browser, each page can have its own viewport size.763        /// <see cref="SetViewportAsync(ViewPortOptions)"/> will resize the page. A lot of websites don't expect phones to change size, so you should set the viewport before navigating to the page.764        /// </summary>765        /// <example>766        ///<![CDATA[767        /// using(var page = await browser.NewPageAsync())768        /// {769        ///     await page.SetViewPortAsync(new ViewPortOptions770        ///     {771        ///         Width = 640, 772        ///         Height = 480, 773        ///         DeviceScaleFactor = 1774        ///     });775        ///     await page.goto('https://www.example.com');776        /// }777        /// ]]>778        /// </example>779        /// <returns>The viewport task.</returns>780        /// <param name="viewport">Viewport options.</param>781        public async Task SetViewportAsync(ViewPortOptions viewport)782        {783            var needsReload = await _emulationManager.EmulateViewport(viewport).ConfigureAwait(false);784            Viewport = viewport;785            if (needsReload)786            {787                await ReloadAsync().ConfigureAwait(false);788            }789        }790        /// <summary>791        /// Closes the page.792        /// </summary>793        /// <param name="options">Close options.</param>794        /// <returns>Task.</returns>795        public Task CloseAsync(PageCloseOptions options = null)796        {797            if (!(Client?.Connection?.IsClosed ?? true))798            {799                var runBeforeUnload = options?.RunBeforeUnload ?? false;800                if (runBeforeUnload)801                {802                    return Client.SendAsync("Page.close");803                }804                return Client.Connection.SendAsync("Target.closeTarget", new TargetCloseTargetRequest805                {806                    TargetId = Target.TargetId807                }).ContinueWith(task => Target.CloseTask);808            }809            return _closeCompletedTcs.Task;810        }811        /// <summary>812        /// Reloads the page813        /// </summary>814        /// <param name="options">Navigation options</param>815        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>816        /// <seealso cref="ReloadAsync(int?, WaitUntilNavigation[])"/>817        public async Task<Response> ReloadAsync(NavigationOptions options)818        {819            var navigationTask = WaitForNavigationAsync(options);820            await Task.WhenAll(821              navigationTask,822              Client.SendAsync("Page.reload")823            ).ConfigureAwait(false);824            return navigationTask.Result;825        }826        /// <summary>827        /// Reloads the page828        /// </summary>829        /// <param name="timeout">Maximum navigation time in milliseconds, defaults to 30 seconds, pass <c>0</c> to disable timeout. </param>830        /// <param name="waitUntil">When to consider navigation succeeded, defaults to <see cref="WaitUntilNavigation.Load"/>. Given an array of <see cref="WaitUntilNavigation"/>, navigation is considered to be successful after all events have been fired</param>831        /// <returns>Task which resolves to the main resource response. In case of multiple redirects, the navigation will resolve with the response of the last redirect</returns>832        /// <seealso cref="ReloadAsync(NavigationOptions)"/>833        public Task<Response> ReloadAsync(int? timeout = null, WaitUntilNavigation[] waitUntil = null)834            => ReloadAsync(new NavigationOptions { Timeout = timeout, WaitUntil = waitUntil });835        /// <summary>836        /// Waits for a function to be evaluated to a truthy value837        /// </summary>838        /// <param name="script">Function to be evaluated in browser context</param>839        /// <param name="options">Optional waiting parameters</param>840        /// <param name="args">Arguments to pass to <c>script</c></param>841        /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>842        /// <seealso cref="Frame.WaitForFunctionAsync(string, WaitForFunctionOptions, object[])"/>843        public Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options = null, params object[] args)844            => MainFrame.WaitForFunctionAsync(script, options ?? new WaitForFunctionOptions(), args);845        /// <summary>846        /// Waits for an expression to be evaluated to a truthy value847        /// </summary>848        /// <param name="script">Expression to be evaluated in browser context</param>849        /// <param name="options">Optional waiting parameters</param>850        /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>851        /// <seealso cref="Frame.WaitForExpressionAsync(string, WaitForFunctionOptions)"/>852        public Task<JSHandle> WaitForExpressionAsync(string script, WaitForFunctionOptions options = null)853            => MainFrame.WaitForExpressionAsync(script, options ?? new WaitForFunctionOptions());854        /// <summary>855        /// Waits for a selector to be added to the DOM856        /// </summary>857        /// <param name="selector">A selector of an element to wait for</param>858        /// <param name="options">Optional waiting parameters</param>859        /// <returns>A task that resolves when element specified by selector string is added to DOM.860        /// Resolves to `null` if waiting for `hidden: true` and selector is not found in DOM.</returns>861        /// <seealso cref="WaitForXPathAsync(string, WaitForSelectorOptions)"/>862        /// <seealso cref="Frame.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>863        public Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)864            => MainFrame.WaitForSelectorAsync(selector, options ?? new WaitForSelectorOptions());865        /// <summary>866        /// Waits for a xpath selector to be added to the DOM867        /// </summary>868        /// <param name="xpath">A xpath selector of an element to wait for</param>869        /// <param name="options">Optional waiting parameters</param>870        /// <returns>A task which resolves when element specified by xpath string is added to DOM. 871        /// Resolves to `null` if waiting for `hidden: true` and xpath is not found in DOM.</returns>872        /// <example>873        /// <code>874        /// <![CDATA[875        /// var browser = await Puppeteer.LaunchAsync(new LaunchOptions());876        /// var page = await browser.NewPageAsync();877        /// string currentURL = null;878        /// page879        ///     .WaitForXPathAsync("//img")880        ///     .ContinueWith(_ => Console.WriteLine("First URL with image: " + currentURL));881        /// foreach (var current in new[] { "https://example.com", "https://google.com", "https://bbc.com" })882        /// {883        ///     currentURL = current;884        ///     await page.GoToAsync(currentURL);885        /// }886        /// await browser.CloseAsync();887        /// ]]>888        /// </code>889        /// </example>890        /// <seealso cref="WaitForSelectorAsync(string, WaitForSelectorOptions)"/>891        /// <seealso cref="Frame.WaitForXPathAsync(string, WaitForSelectorOptions)"/>892        public Task<ElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)893            => MainFrame.WaitForXPathAsync(xpath, options ?? new WaitForSelectorOptions());894        /// <summary>895        /// This resolves when the page navigates to a new URL or reloads.896        /// It is useful for when you run code which will indirectly cause the page to navigate.897        /// </summary>898        /// <param name="options">navigation options</param>899        /// <returns>Task which resolves to the main resource response. 900        /// In case of multiple redirects, the navigation will resolve with the response of the last redirect.901        /// In case of navigation to a different anchor or navigation due to History API usage, the navigation will resolve with `null`.902        /// </returns>903        /// <remarks>904        /// Usage of the <c>History API</c> <see href="https://developer.mozilla.org/en-US/docs/Web/API/History_API"/> to change the URL is considered a navigation905        /// </remarks>906        /// <example>907        /// <code>908        /// <![CDATA[909        /// var navigationTask = page.WaitForNavigationAsync();910        /// await page.ClickAsync("a.my-link");911        /// await navigationTask;912        /// ]]>913        /// </code>914        /// </example>915        public Task<Response> WaitForNavigationAsync(NavigationOptions options = null) => FrameManager.WaitForFrameNavigationAsync(FrameManager.MainFrame, options);916        /// <summary>917        /// Waits for a request.918        /// </summary>919        /// <example>920        /// <code>921        /// <![CDATA[922        /// var firstRequest = await page.WaitForRequestAsync("http://example.com/resource");923        /// return firstRequest.Url;924        /// ]]>925        /// </code>926        /// </example>927        /// <returns>A task which resolves when a matching request was made.</returns>928        /// <param name="url">URL to wait for.</param>929        /// <param name="options">Options.</param>930        public Task<Request> WaitForRequestAsync(string url, WaitForOptions options = null)931            => WaitForRequestAsync(request => request.Url == url, options);932        /// <summary>933        /// Waits for a request.934        /// </summary>935        /// <example>936        /// <code>937        /// <![CDATA[938        /// var request = await page.WaitForRequestAsync(request => request.Url === "http://example.com" && request.Method === HttpMethod.Get;939        /// return request.Url;940        /// ]]>941        /// </code>942        /// </example>943        /// <returns>A task which resolves when a matching request was made.</returns>944        /// <param name="predicate">Function which looks for a matching request.</param>945        /// <param name="options">Options.</param>946        public async Task<Request> WaitForRequestAsync(Func<Request, bool> predicate, WaitForOptions options = null)947        {948            var timeout = options?.Timeout ?? DefaultTimeout;949            var requestTcs = new TaskCompletionSource<Request>(TaskCreationOptions.RunContinuationsAsynchronously);950            void requestEventListener(object sender, RequestEventArgs e)951            {952                if (predicate(e.Request))953                {954                    requestTcs.TrySetResult(e.Request);955                    FrameManager.NetworkManager.Request -= requestEventListener;956                }957            }958            FrameManager.NetworkManager.Request += requestEventListener;959            await Task.WhenAny(requestTcs.Task, SessionClosedTask).WithTimeout(timeout, t =>960            {961                FrameManager.NetworkManager.Request -= requestEventListener;962                return new TimeoutException($"Timeout of {t.TotalMilliseconds} ms exceeded");963            }).ConfigureAwait(false);964            if (SessionClosedTask.IsFaulted)965            {966                await SessionClosedTask.ConfigureAwait(false);967            }968            return await requestTcs.Task.ConfigureAwait(false);969        }970        /// <summary>971        /// Waits for a response.972        /// </summary>973        /// <example>974        /// <code>975        /// <![CDATA[976        /// var firstResponse = await page.WaitForResponseAsync("http://example.com/resource");977        /// return firstResponse.Url;978        /// ]]>979        /// </code>980        /// </example>981        /// <returns>A task which resolves when a matching response is received.</returns>982        /// <param name="url">URL to wait for.</param>983        /// <param name="options">Options.</param>984        public Task<Response> WaitForResponseAsync(string url, WaitForOptions options = null)985            => WaitForResponseAsync(response => response.Url == url, options);986        /// <summary>987        /// Waits for a response.988        /// </summary>989        /// <example>990        /// <code>991        /// <![CDATA[992        /// var response = await page.WaitForResponseAsync(response => response.Url === "http://example.com" && response.Status === HttpStatus.Ok;993        /// return response.Url;994        /// ]]>995        /// </code>996        /// </example>997        /// <returns>A task which resolves when a matching response is received.</returns>998        /// <param name="predicate">Function which looks for a matching response.</param>999        /// <param name="options">Options.</param>1000        public async Task<Response> WaitForResponseAsync(Func<Response, bool> predicate, WaitForOptions options = null)1001        {1002            var timeout = options?.Timeout ?? DefaultTimeout;1003            var responseTcs = new TaskCompletionSource<Response>(TaskCreationOptions.RunContinuationsAsynchronously);1004            void responseEventListener(object sender, ResponseCreatedEventArgs e)1005            {1006                if (predicate(e.Response))1007                {1008                    responseTcs.TrySetResult(e.Response);1009                    FrameManager.NetworkManager.Response -= responseEventListener;1010                }1011            }1012            FrameManager.NetworkManager.Response += responseEventListener;1013            await Task.WhenAny(responseTcs.Task, SessionClosedTask).WithTimeout(timeout).ConfigureAwait(false);1014            if (SessionClosedTask.IsFaulted)1015            {1016                await SessionClosedTask.ConfigureAwait(false);1017            }1018            return await responseTcs.Task.ConfigureAwait(false);1019        }1020        /// <summary>1021        /// Navigate to the previous page in history.1022        /// </summary>1023        /// <returns>Task that resolves to the main resource response. In case of multiple redirects, 1024        /// the navigation will resolve with the response of the last redirect. If can not go back, resolves to null.</returns>1025        /// <param name="options">Navigation parameters.</param>1026        public Task<Response> GoBackAsync(NavigationOptions options = null) => GoAsync(-1, options);1027        /// <summary>1028        /// Navigate to the next page in history.1029        /// </summary>1030        /// <returns>Task that resolves to the main resource response. In case of multiple redirects, 1031        /// the navigation will resolve with the response of the last redirect. If can not go forward, resolves to null.</returns>1032        /// <param name="options">Navigation parameters.</param>1033        public Task<Response> GoForwardAsync(NavigationOptions options = null) => GoAsync(1, options);1034        /// <summary>1035        /// Resets the background color and Viewport after taking Screenshots using BurstMode.1036        /// </summary>1037        /// <returns>The burst mode off.</returns>1038        public Task SetBurstModeOffAsync()1039        {1040            return Task.CompletedTask;1041        }1042        #endregion1043        internal void OnPopup(Page popupPage) => Popup?.Invoke(this, new PopupEventArgs { PopupPage = popupPage });1044        #region Private Method1045        internal static async Task<Page> CreateAsync(1046            CDPSession client,1047            Target target,1048            bool ignoreHTTPSErrors,1049            ViewPortOptions defaultViewPort,1050            TaskQueue screenshotTaskQueue)1051        {1052            var page = new Page(client, target, screenshotTaskQueue);1053            await page.InitializeAsync(ignoreHTTPSErrors).ConfigureAwait(false);1054            if (defaultViewPort != null)1055            {1056                await page.SetViewportAsync(defaultViewPort).ConfigureAwait(false);1057            }1058            return page;1059        }1060        private async Task InitializeAsync(bool ignoreHTTPSErrors)1061        {1062            FrameManager = await FrameManager.CreateFrameManagerAsync(Client, this, ignoreHTTPSErrors, _timeoutSettings).ConfigureAwait(false);1063            var networkManager = FrameManager.NetworkManager;1064            Client.MessageReceived += Client_MessageReceived;1065            FrameManager.FrameAttached += (sender, e) => FrameAttached?.Invoke(this, e);1066            FrameManager.FrameDetached += (sender, e) => FrameDetached?.Invoke(this, e);1067            FrameManager.FrameNavigated += (sender, e) => FrameNavigated?.Invoke(this, e);1068            networkManager.Request += (sender, e) => Request?.Invoke(this, e);1069            networkManager.RequestFailed += (sender, e) => RequestFailed?.Invoke(this, e);1070            networkManager.Response += (sender, e) => Response?.Invoke(this, e);1071            networkManager.RequestFinished += (sender, e) => RequestFinished?.Invoke(this, e);1072            await Task.WhenAll(1073               Client.SendAsync("Target.setAutoAttach", new TargetSetAutoAttachRequest1074               {1075                   AutoAttach = true,1076                   WaitForDebuggerOnStart = false,1077                   Flatten = true1078               }),1079               Client.SendAsync("Performance.enable", null),1080               Client.SendAsync("Log.enable", null)1081           ).ConfigureAwait(false);...

...16    /// ElementHandles can be created by <see cref="PuppeteerSharp.Page.QuerySelectorAsync(string)"/> or <see cref="PuppeteerSharp.Page.QuerySelectorAllAsync(string)"/>.17    /// </summary>18    public class ElementHandle : JSHandle19    {20        private readonly FrameManager _frameManager;21        private readonly ILogger<ElementHandle> _logger;22        internal ElementHandle(23            ExecutionContext context,24            CDPSession client,25            RemoteObject remoteObject,26            Page page,27            FrameManager frameManager) : base(context, client, remoteObject)28        {29            Page = page;30            _frameManager = frameManager;31            _logger = client.LoggerFactory.CreateLogger<ElementHandle>();32        }33        internal Page Page { get; }34        /// <summary>35        /// This method scrolls element into view if needed, and then uses <seealso cref="PuppeteerSharp.Page.ScreenshotDataAsync(ScreenshotOptions)"/> to take a screenshot of the element.36        /// If the element is detached from DOM, the method throws an error.37        /// </summary>38        /// <returns>The task</returns>39        /// <param name="file">The file path to save the image to. The screenshot type will be inferred from file extension.40        /// If path is a relative path, then it is resolved relative to current working directory. If no path is provided,41        /// the image won't be saved to the disk.</param>...

...8using System.Linq;9using System.Threading.Tasks;10namespace PuppeteerSharp11{12    internal class FrameManager13    {14        private Dictionary<int, ExecutionContext> _contextIdToContext;15        private bool _ensureNewDocumentNavigation;16        private readonly ConcurrentDictionary<string, Frame> _frames;17        private const string RefererHeaderName = "referer";18        private readonly AsyncDictionaryHelper<string, Frame> _asyncFrames;19        private readonly List<string> _isolatedWorlds = new List<string>();20        private const string UtilityWorldName = "__puppeteer_utility_world__";21        private FrameManager(CDPSession client, Page page, bool ignoreHTTPSErrors, TimeoutSettings timeoutSettings)22        {23            Client = client;24            Page = page;25            _frames = new ConcurrentDictionary<string, Frame>();26            _contextIdToContext = new Dictionary<int, ExecutionContext>();27            NetworkManager = new NetworkManager(client, ignoreHTTPSErrors, this);28            TimeoutSettings = timeoutSettings;29            _asyncFrames = new AsyncDictionaryHelper<string, Frame>(_frames, "Frame {0} not found");30            Client.MessageReceived += Client_MessageReceived;31        }32        #region Properties33        internal event EventHandler<FrameEventArgs> FrameAttached;34        internal event EventHandler<FrameEventArgs> FrameDetached;35        internal event EventHandler<FrameEventArgs> FrameNavigated;36        internal event EventHandler<FrameEventArgs> FrameNavigatedWithinDocument;37        internal event EventHandler<FrameEventArgs> LifecycleEvent;38        internal CDPSession Client { get; }39        internal NetworkManager NetworkManager { get; }40        internal Frame MainFrame { get; set; }41        internal Page Page { get; }42        internal TimeoutSettings TimeoutSettings { get; }43        #endregion44        #region Public Methods45        internal static async Task<FrameManager> CreateFrameManagerAsync(46            CDPSession client,47            Page page,48            bool ignoreHTTPSErrors,49            TimeoutSettings timeoutSettings)50        {51            var frameManager = new FrameManager(client, page, ignoreHTTPSErrors, timeoutSettings);52            var getFrameTreeTask = client.SendAsync<PageGetFrameTreeResponse>("Page.getFrameTree");53            await Task.WhenAll(54                client.SendAsync("Page.enable"),55                getFrameTreeTask).ConfigureAwait(false);56            await frameManager.HandleFrameTreeAsync(new FrameTree(getFrameTreeTask.Result.FrameTree)).ConfigureAwait(false);57            await Task.WhenAll(58                client.SendAsync("Page.setLifecycleEventsEnabled", new PageSetLifecycleEventsEnabledRequest { Enabled = true }),59                client.SendAsync("Runtime.enable"),60                frameManager.NetworkManager.InitializeAsync()).ConfigureAwait(false);61            await frameManager.EnsureIsolatedWorldAsync().ConfigureAwait(false);62            return frameManager;63        }64        internal ExecutionContext ExecutionContextById(int contextId)65        {...

...23        private bool _protocolRequestInterceptionEnabled;24        private readonly bool _ignoreHTTPSErrors;25        private bool _userCacheDisabled;26        #endregion27        internal NetworkManager(CDPSession client, bool ignoreHTTPSErrors, FrameManager frameManager)28        {29            FrameManager = frameManager;30            _client = client;31            _ignoreHTTPSErrors = ignoreHTTPSErrors;32            _client.MessageReceived += Client_MessageReceived;33        }34        #region Public Properties35        internal Dictionary<string, string> ExtraHTTPHeaders => _extraHTTPHeaders?.Clone();36        internal event EventHandler<ResponseCreatedEventArgs> Response;37        internal event EventHandler<RequestEventArgs> Request;38        internal event EventHandler<RequestEventArgs> RequestFinished;39        internal event EventHandler<RequestEventArgs> RequestFailed;40        internal FrameManager FrameManager { get; set; }41        #endregion42        #region Public Methods43        internal async Task InitializeAsync()44        {45            await _client.SendAsync("Network.enable").ConfigureAwait(false);46            if (_ignoreHTTPSErrors)47            {48                await _client.SendAsync("Security.setIgnoreCertificateErrors", new SecuritySetIgnoreCertificateErrorsRequest49                {50                    Ignore = true51                }).ConfigureAwait(false);52            }53        }54        internal Task AuthenticateAsync(Credentials credentials)55        {56            _credentials = credentials;57            return UpdateProtocolRequestInterceptionAsync();58        }59        internal Task SetExtraHTTPHeadersAsync(Dictionary<string, string> extraHTTPHeaders)60        {61            _extraHTTPHeaders = new Dictionary<string, string>();62            foreach (var item in extraHTTPHeaders)63            {64                _extraHTTPHeaders[item.Key.ToLower()] = item.Value;65            }66            return _client.SendAsync("Network.setExtraHTTPHeaders", new NetworkSetExtraHTTPHeadersRequest67            {68                Headers = _extraHTTPHeaders69            });70        }71        internal async Task SetOfflineModeAsync(bool value)72        {73            if (_offine != value)74            {75                _offine = value;76                await _client.SendAsync("Network.emulateNetworkConditions", new NetworkEmulateNetworkConditionsRequest77                {78                    Offline = value,79                    Latency = 0,80                    DownloadThroughput = -1,81                    UploadThroughput = -182                }).ConfigureAwait(false);83            }84        }85        internal Task SetUserAgentAsync(string userAgent)86            => _client.SendAsync("Network.setUserAgentOverride", new NetworkSetUserAgentOverrideRequest87            {88                UserAgent = userAgent89            });90        internal Task SetCacheEnabledAsync(bool enabled)91        {92            _userCacheDisabled = !enabled;93            return UpdateProtocolCacheDisabledAsync();94        }95        internal Task SetRequestInterceptionAsync(bool value)96        {97            _userRequestInterceptionEnabled = value;98            return UpdateProtocolRequestInterceptionAsync();99        }100        #endregion101        #region Private Methods102        private Task UpdateProtocolCacheDisabledAsync()103            => _client.SendAsync("Network.setCacheDisabled", new NetworkSetCacheDisabledRequest104            {105                CacheDisabled = _userCacheDisabled || _protocolRequestInterceptionEnabled106            });107        private async void Client_MessageReceived(object sender, MessageEventArgs e)108        {109            try110            {111                switch (e.MessageID)112                {113                    case "Fetch.requestPaused":114                        await OnRequestPausedAsync(e.MessageData.ToObject<FetchRequestPausedResponse>(true)).ConfigureAwait(false);115                        break;116                    case "Fetch.authRequired":117                        await OnAuthRequiredAsync(e.MessageData.ToObject<FetchAuthRequiredResponse>(true)).ConfigureAwait(false);118                        break;119                    case "Network.requestWillBeSent":120                        await OnRequestWillBeSentAsync(e.MessageData.ToObject<RequestWillBeSentPayload>(true)).ConfigureAwait(false);121                        break;122                    case "Network.requestServedFromCache":123                        OnRequestServedFromCache(e.MessageData.ToObject<RequestServedFromCacheResponse>(true));124                        break;125                    case "Network.responseReceived":126                        OnResponseReceived(e.MessageData.ToObject<ResponseReceivedResponse>(true));127                        break;128                    case "Network.loadingFinished":129                        OnLoadingFinished(e.MessageData.ToObject<LoadingFinishedResponse>(true));130                        break;131                    case "Network.loadingFailed":132                        OnLoadingFailed(e.MessageData.ToObject<LoadingFailedResponse>(true));133                        break;134                }135            }136            catch (Exception ex)137            {138                var message = $"NetworkManager failed to process {e.MessageID}. {ex.Message}. {ex.StackTrace}";139                _client.Close(message);140            }141        }142        private void OnLoadingFailed(LoadingFailedResponse e)143        {144            // For certain requestIds we never receive requestWillBeSent event.145            // @see https://crbug.com/750469146            if (_requestIdToRequest.TryGetValue(e.RequestId, out var request))147            {148                request.Failure = e.ErrorText;149                request.Response?.BodyLoadedTaskWrapper.TrySetResult(true);150                _requestIdToRequest.TryRemove(request.RequestId, out _);151                if (request.InterceptionId != null)152                {153                    _attemptedAuthentications.Remove(request.InterceptionId);154                }155                RequestFailed?.Invoke(this, new RequestEventArgs156                {157                    Request = request158                });159            }160        }161        private void OnLoadingFinished(LoadingFinishedResponse e)162        {163            // For certain requestIds we never receive requestWillBeSent event.164            // @see https://crbug.com/750469165            if (_requestIdToRequest.TryGetValue(e.RequestId, out var request))166            {167                request.Response?.BodyLoadedTaskWrapper.TrySetResult(true);168                _requestIdToRequest.TryRemove(request.RequestId, out _);169                if (request.InterceptionId != null)170                {171                    _attemptedAuthentications.Remove(request.InterceptionId);172                }173                RequestFinished?.Invoke(this, new RequestEventArgs174                {175                    Request = request176                });177            }178        }179        private void OnResponseReceived(ResponseReceivedResponse e)180        {181            // FileUpload sends a response without a matching request.182            if (_requestIdToRequest.TryGetValue(e.RequestId, out var request))183            {184                var response = new Response(185                    _client,186                    request,187                    e.Response);188                request.Response = response;189                Response?.Invoke(this, new ResponseCreatedEventArgs190                {191                    Response = response192                });193            }194        }195        private async Task OnAuthRequiredAsync(FetchAuthRequiredResponse e)196        {197            var response = "Default";198            if (_attemptedAuthentications.Contains(e.RequestId))199            {200                response = "CancelAuth";201            }202            else if (_credentials != null)203            {204                response = "ProvideCredentials";205                _attemptedAuthentications.Add(e.RequestId);206            }207            var credentials = _credentials ?? new Credentials();208            try209            {210                await _client.SendAsync("Fetch.continueWithAuth", new ContinueWithAuthRequest211                {212                    RequestId = e.RequestId,213                    AuthChallengeResponse = new ContinueWithAuthRequestChallengeResponse214                    {215                        Response = response,216                        Username = credentials.Username,217                        Password = credentials.Password218                    }219                }).ConfigureAwait(false);220            }221            catch { }222        }223        private async Task OnRequestPausedAsync(FetchRequestPausedResponse e)224        {225            if (!_userRequestInterceptionEnabled && _protocolRequestInterceptionEnabled)226            {227                try228                {229                    await _client.SendAsync("Fetch.continueRequest", new FetchContinueRequestRequest230                    {231                        RequestId = e.RequestId232                    }).ConfigureAwait(false);233                }234                catch { }235            }236            var requestId = e.NetworkId;237            var interceptionId = e.RequestId;238            if (!string.IsNullOrEmpty(requestId))239            {240                if (_requestIdToRequestWillBeSentEvent.TryRemove(requestId, out var requestWillBeSentEvent))241                {242                    await OnRequestAsync(requestWillBeSentEvent, interceptionId).ConfigureAwait(false);243                }244                else245                {246                    _requestIdToInterceptionId[requestId] = interceptionId;247                }248            }249        }250        private async Task OnRequestAsync(RequestWillBeSentPayload e, string interceptionId)251        {252            Request request;253            var redirectChain = new List<Request>();254            if (e.RedirectResponse != null)255            {256                _requestIdToRequest.TryGetValue(e.RequestId, out request);257                // If we connect late to the target, we could have missed the requestWillBeSent event.258                if (request != null)259                {260                    HandleRequestRedirect(request, e.RedirectResponse);261                    redirectChain = request.RedirectChainList;262                }263            }264            if (!_requestIdToRequest.TryGetValue(e.RequestId, out var currentRequest) ||265              currentRequest.Frame == null)266            {267                var frame = !string.IsNullOrEmpty(e.FrameId) ? await FrameManager.TryGetFrameAsync(e.FrameId).ConfigureAwait(false) : null;268                request = new Request(269                    _client,270                    frame,271                    interceptionId,272                    _userRequestInterceptionEnabled,273                    e,274                    redirectChain);275                _requestIdToRequest[e.RequestId] = request;276                Request?.Invoke(this, new RequestEventArgs277                {278                    Request = request279                });280            }281        }...

...6namespace PuppeteerSharp7{8    internal class DOMWorld9    {10        private readonly FrameManager _frameManager;11        private readonly TimeoutSettings _timeoutSettings;12        private bool _detached;13        private TaskCompletionSource<ExecutionContext> _contextResolveTaskWrapper;14        private TaskCompletionSource<ElementHandle> _documentCompletionSource;15        internal List<WaitTask> WaitTasks { get; set; }16        internal Frame Frame { get; }17        public DOMWorld(FrameManager frameManager, Frame frame, TimeoutSettings timeoutSettings)18        {19            _frameManager = frameManager;20            Frame = frame;21            _timeoutSettings = timeoutSettings;22            SetContext(null);23            WaitTasks = new List<WaitTask>();24            _detached = false;25        }26        internal void SetContext(ExecutionContext context)27        {28            if (context != null)29            {30                _contextResolveTaskWrapper.TrySetResult(context);31                foreach (var waitTask in WaitTasks)...

...160            }161        }162        internal JSHandle CreateJSHandle(RemoteObject remoteObject)163            => remoteObject.Subtype == RemoteObjectSubtype.Node && Frame != null164                ? new ElementHandle(this, _client, remoteObject, Frame.FrameManager.Page, Frame.FrameManager)165                : new JSHandle(this, _client, remoteObject);166        private object FormatArgument(object arg)167        {168            switch (arg)169            {170                case BigInteger big:171                    return new { unserializableValue = $"{big}n" };172                case int integer when integer == -0:173                    return new { unserializableValue = "-0" };174                case double d:175                    if (double.IsPositiveInfinity(d))176                    {177                        return new { unserializableValue = "Infinity" };178                    }...

...16                [WaitUntilNavigation.Networkidle0] = "networkIdle",17                [WaitUntilNavigation.Networkidle2] = "networkAlmostIdle"18            };19        private static readonly WaitUntilNavigation[] _defaultWaitUntil = { WaitUntilNavigation.Load };20        private readonly FrameManager _frameManager;21        private readonly Frame _frame;22        private readonly IEnumerable<string> _expectedLifecycle;23        private readonly int _timeout;24        private readonly string _initialLoaderId;25        private Request _navigationRequest;26        private bool _hasSameDocumentNavigation;27        private TaskCompletionSource<bool> _newDocumentNavigationTaskWrapper;28        private TaskCompletionSource<bool> _sameDocumentNavigationTaskWrapper;29        private TaskCompletionSource<bool> _lifecycleTaskWrapper;30        private TaskCompletionSource<bool> _terminationTaskWrapper;31        public LifecycleWatcher(32            FrameManager frameManager,33            Frame frame,34            WaitUntilNavigation[] waitUntil,35            int timeout)36        {37            _expectedLifecycle = (waitUntil ?? _defaultWaitUntil).Select(w =>38            {39                var protocolEvent = _puppeteerToProtocolLifecycle.GetValueOrDefault(w);40                Contract.Assert(protocolEvent != null, $"Unknown value for options.waitUntil: {w}");41                return protocolEvent;42            });43            _frameManager = frameManager;44            _frame = frame;45            _initialLoaderId = frame.LoaderId;46            _timeout = timeout;47            _hasSameDocumentNavigation = false;48            _sameDocumentNavigationTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);49            _newDocumentNavigationTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);50            _lifecycleTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);51            _terminationTaskWrapper = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);52            frameManager.LifecycleEvent += FrameManager_LifecycleEvent;53            frameManager.FrameNavigatedWithinDocument += NavigatedWithinDocument;54            frameManager.FrameDetached += OnFrameDetached;55            frameManager.NetworkManager.Request += OnRequest;56            frameManager.Client.Disconnected += OnClientDisconnected;57            CheckLifecycleComplete();58        }59        #region Properties60        public Task<Task> NavigationTask { get; internal set; }61        public Task<bool> SameDocumentNavigationTask => _sameDocumentNavigationTaskWrapper.Task;62        public Task<bool> NewDocumentNavigationTask => _newDocumentNavigationTaskWrapper.Task;63        public Response NavigationResponse => _navigationRequest?.Response;64        public Task TimeoutOrTerminationTask65            => _terminationTaskWrapper.Task.WithTimeout(_timeout);66        public Task LifecycleTask => _lifecycleTaskWrapper.Task;67        #endregion68        #region Private methods69        private void OnClientDisconnected(object sender, EventArgs e)70            => Terminate(new TargetClosedException("Navigation failed because browser has disconnected!", _frameManager.Client.CloseReason));71        void FrameManager_LifecycleEvent(object sender, FrameEventArgs e) => CheckLifecycleComplete();7273        private void OnFrameDetached(object sender, FrameEventArgs e)74        {75            var frame = e.Frame;76            if (_frame == frame)77            {78                Terminate(new PuppeteerException("Navigating frame was detached"));79                return;80            }81            CheckLifecycleComplete();82        }83        private void CheckLifecycleComplete()84        {85            // We expect navigation to commit.86            if (!CheckLifecycle(_frame, _expectedLifecycle))87            {88                return;89            }90            _lifecycleTaskWrapper.TrySetResult(true);91            if (_frame.LoaderId == _initialLoaderId && !_hasSameDocumentNavigation)92            {93                return;94            }95            if (_hasSameDocumentNavigation)96            {97                _sameDocumentNavigationTaskWrapper.TrySetResult(true);98            }99            if (_frame.LoaderId != _initialLoaderId)100            {101                _newDocumentNavigationTaskWrapper.TrySetResult(true);102            }103        }104        private void Terminate(PuppeteerException ex) => _terminationTaskWrapper.TrySetException(ex);105        private void OnRequest(object sender, RequestEventArgs e)106        {107            if (e.Request.Frame != _frame || !e.Request.IsNavigationRequest)108            {109                return;110            }111            _navigationRequest = e.Request;112        }113        private void NavigatedWithinDocument(object sender, FrameEventArgs e)114        {115            if (e.Frame != _frame)116            {117                return;118            }119            _hasSameDocumentNavigation = true;120            CheckLifecycleComplete();121        }122        private bool CheckLifecycle(Frame frame, IEnumerable<string> expectedLifecycle)123        {124            foreach (var item in expectedLifecycle)125            {126                if (!frame.LifecycleEvents.Contains(item))127                {128                    return false;129                }130            }131            foreach (var child in frame.ChildFrames)132            {133                if (!CheckLifecycle(child, expectedLifecycle))134                {135                    return false;136                }137            }138            return true;139        }140        public void Dispose() => Dispose(true);141        ~LifecycleWatcher() => Dispose(false);142        public void Dispose(bool disposing)143        {144            _frameManager.LifecycleEvent -= FrameManager_LifecycleEvent;145            _frameManager.FrameNavigatedWithinDocument -= NavigatedWithinDocument;146            _frameManager.FrameDetached -= OnFrameDetached;147            _frameManager.NetworkManager.Request -= OnRequest;148            _frameManager.Client.Disconnected -= OnClientDisconnected;149        }150        #endregion151    }152}...

...16            [WaitUntilNavigation.DOMContentLoaded] = "DOMContentLoaded",17            [WaitUntilNavigation.Networkidle0] = "networkIdle",18            [WaitUntilNavigation.Networkidle2] = "networkAlmostIdle"19        };20        private FrameManager _frameManager;21        private Frame _frame;22        private NavigationOptions _options;23        private IEnumerable<string> _expectedLifecycle;24        private int _timeout;25        private string _initialLoaderId;26        public NavigatorWatcher(FrameManager frameManager, Frame mainFrame, int timeout, NavigationOptions options)27        {28            var waitUntil = new[] { WaitUntilNavigation.Load };2930            if (options?.WaitUntil != null)31            {32                waitUntil = options.WaitUntil;33            }3435            _expectedLifecycle = waitUntil.Select(w =>36            {37                var protocolEvent = _puppeteerToProtocolLifecycle.GetValueOrDefault(w);38                Contract.Assert(protocolEvent != null, $"Unknown value for options.waitUntil: {w}");39                return protocolEvent;40            });4142            _frameManager = frameManager;43            _frame = mainFrame;44            _options = options;45            _initialLoaderId = mainFrame.LoaderId;46            _timeout = timeout;4748            frameManager.LifecycleEvent += FrameManager_LifecycleEvent;49            frameManager.FrameDetached += FrameManager_LifecycleEvent;50            LifeCycleCompleteTaskWrapper = new TaskCompletionSource<bool>();5152            NavigationTask = Task.WhenAny(new[]53            {54                CreateTimeoutTask(),55                LifeCycleCompleteTask,56            }).ContinueWith((task) =>57            {58                CleanUp();59                return task.GetAwaiter().GetResult();60            });61        }62        #region Properties63        public Task<Task> NavigationTask { get; internal set; }64        public Task<bool> LifeCycleCompleteTask => LifeCycleCompleteTaskWrapper.Task;65        public TaskCompletionSource<bool> LifeCycleCompleteTaskWrapper { get; }66        #endregion67        #region Public methods68        public void Cancel()69        {70            CleanUp();71        }72        #endregion73        #region Private methods74        void FrameManager_LifecycleEvent(object sender, FrameEventArgs e)75        {76            // We expect navigation to commit.77            if (_frame.LoaderId == _initialLoaderId)78            {79                return;80            }81            if (!CheckLifecycle(_frame, _expectedLifecycle))82            {83                return;84            }8586            if (!LifeCycleCompleteTaskWrapper.Task.IsCompleted)87            {88                LifeCycleCompleteTaskWrapper.SetResult(true);89            }90        }9192        private bool CheckLifecycle(Frame frame, IEnumerable<string> expectedLifecycle)93        {94            foreach (var item in expectedLifecycle)95            {96                if (!frame.LifecycleEvents.Contains(item))97                {98                    return false;99                }100            }101            foreach (var child in frame.ChildFrames)102            {103                if (!CheckLifecycle(child, expectedLifecycle))104                {105                    return false;106                }107            }108            return true;109        }110        private void CleanUp()111        {112            _frameManager.LifecycleEvent -= FrameManager_LifecycleEvent;113            _frameManager.FrameDetached -= FrameManager_LifecycleEvent;114        }115        private async Task CreateTimeoutTask()116        {117            var wrapper = new TaskCompletionSource<bool>();118119            if (_timeout == 0)120            {121                await Task.Delay(-1);122            }123            else124            {125                await Task.Delay(_timeout);126                throw new NavigationException($"Navigation Timeout Exceeded: {_timeout}ms exceeded");127            }
...

1using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions2{3    Args = new[] { "--no-sandbox" }4}))5{6    var page = await browser.NewPageAsync();7    await page.ScreenshotAsync("screenshot.png");8}9using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions10{11    Args = new[] { "--no-sandbox" }12}))13{14    var page = await browser.NewPageAsync();15    await page.ScreenshotAsync("screenshot.png");16}17using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions18{19    Args = new[] { "--no-sandbox" }20}))21{22    var page = await browser.NewPageAsync();23    await page.ScreenshotAsync("screenshot.png");24}25using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions26{27    Args = new[] { "--no-sandbox" }28}))29{30    var page = await browser.NewPageAsync();31    await page.ScreenshotAsync("screenshot.png");32}33using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions34{35    Args = new[] { "--no-sandbox" }36}))37{38    var page = await browser.NewPageAsync();39    await page.ScreenshotAsync("screenshot.png");40}41using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions42{43    Args = new[] { "--no-sandbox" }44}))45{

1using PuppeteerSharp;2using System;3using System.Threading.Tasks;4{5    {6        static async Task Main(string[] args)7        {8            var browser = await Puppeteer.LaunchAsync(new LaunchOptions9            {10                Args = new string[] { "--start-maximized" }11            });12            var page = await browser.NewPageAsync();13            await page.ScreenshotAsync("google.png");14            await browser.CloseAsync();15        }16    }17}

1using System;2using System.Threading.Tasks;3using PuppeteerSharp;4{5    {6        static async Task Main(string[] args)7        {8            Console.WriteLine("Hello World!");9            {10            };11            using (var browser = await Puppeteer.LaunchAsync(options))12            {13                using (var page = await browser.NewPageAsync())14                {15                    await page.ScreenshotAsync("google.png");16                    var frames = await page.FramesAsync();17                    foreach (var frame in frames)18                    {19                        Console.WriteLine(frame.Name);20                    }21                    var frame2 = await page.FrameAsync("iframe");22                    var button = await frame2.QuerySelectorAsync("button");23                    await button.ClickAsync();