// Copyright © 2015 The CefSharp Authors. All rights reserved.

//

// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

using System;

using System.Collections.Generic;

using System.Collections.Specialized;

using System.ComponentModel;

using System.Globalization;

using System.IO;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using CefSharp.Internals;

using CefSharp.Web;

namespace CefSharp

{

/// <summary>

/// WebBrowser extensions - These methods make performing common tasks easier.

/// </summary>

public static class WebBrowserExtensions

{

public const string BrowserNullExceptionString = "IBrowser instance is null. Browser has likely not finished initializing or is in the process of disposing.";

public const string BrowserHostNullExceptionString = "IBrowserHost instance is null. Browser has likely not finished initializing or is in the process of disposing.";

public const string FrameNullExceptionString = "IFrame instance is null. Browser has likely not finished initializing or is in the process of disposing.";

#region Legacy Javascript Binding

/// <summary>

/// Registers a Javascript object in this specific browser instance.

/// </summary>

/// <param name="webBrowser">The browser to perform the registering on.</param>

/// <param name="name">The name of the object. (e.g. "foo", if you want the object to be accessible as window.foo).</param>

/// <param name="objectToBind">The object to be made accessible to Javascript.</param>

/// <param name="options">(Optional) binding options - camelCaseJavascriptNames default to true.</param>

/// <exception cref="Exception">Browser is already initialized. RegisterJsObject must be +

/// called before the underlying CEF browser is created.</exception>

[Obsolete("This method has been removed, see https://github.com/cefsharp/CefSharp/issues/2990 for details on migrating your code.")]

[EditorBrowsable(EditorBrowsableState.Never)]

public static void RegisterJsObject(this IWebBrowser webBrowser, string name, object objectToBind, BindingOptions options = null)

{

throw new NotImplementedException("This method has been removed, see https://github.com/cefsharp/CefSharp/issues/2990 for details on migrating your code.");

}

/// <summary>

/// <para>Asynchronously registers a Javascript object in this specific browser instance.</para>

/// <para>Only methods of the object will be availabe.</para>

/// </summary>

/// <param name="webBrowser">The browser to perform the registering on</param>

/// <param name="name">The name of the object. (e.g. "foo", if you want the object to be accessible as window.foo).</param>

/// <param name="objectToBind">The object to be made accessible to Javascript.</param>

/// <param name="options">binding options - camelCaseJavascriptNames default to true </param>

/// <exception cref="Exception">Browser is already initialized. RegisterJsObject must be +

/// called before the underlying CEF browser is created.</exception>

/// <remarks>The registered methods can only be called in an async way, they will all return immediately and the resulting

/// object will be a standard javascript Promise object which is usable to wait for completion or failure.</remarks>

[Obsolete("This method has been removed, see https://github.com/cefsharp/CefSharp/issues/2990 for details on migrating your code.")]

[EditorBrowsable(EditorBrowsableState.Never)]

public static void RegisterAsyncJsObject(this IWebBrowser webBrowser, string name, object objectToBind, BindingOptions options = null)

{

throw new NotImplementedException("This method has been removed, see https://github.com/cefsharp/CefSharp/issues/2990 for details on migrating your code.");

}

#endregion

/// <summary>

/// Returns the main (top-level) frame for the browser window.

/// </summary>

/// <param name="browser">the ChromiumWebBrowser instance.</param>

/// <returns> the main frame. </returns>

public static IFrame GetMainFrame(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

var cefBrowser = browser.BrowserCore;

ThrowExceptionIfBrowserNull(cefBrowser);

return cefBrowser.MainFrame;

}

/// <summary>

/// Returns the focused frame for the browser window.

/// </summary>

/// <param name="browser">the ChromiumWebBrowser instance.</param>

/// <returns>the focused frame.</returns>

public static IFrame GetFocusedFrame(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

var cefBrowser = browser.BrowserCore;

ThrowExceptionIfBrowserNull(cefBrowser);

return cefBrowser.FocusedFrame;

}

/// <summary>

/// Execute Undo on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void Undo(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.Undo();

}

/// <summary>

/// Execute Undo on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void Undo(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.Undo();

}

}

/// <summary>

/// Execute Redo on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void Redo(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.Redo();

}

/// <summary>

/// Execute Redo on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void Redo(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.Redo();

}

}

/// <summary>

/// Execute Cut on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void Cut(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.Cut();

}

/// <summary>

/// Execute Cut on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void Cut(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.Cut();

}

}

/// <summary>

/// Execute Copy on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void Copy(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.Copy();

}

/// <summary>

/// Execute Copy on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void Copy(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.Copy();

}

}

/// <summary>

/// Execute Paste on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void Paste(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.Paste();

}

/// <summary>

/// Execute Paste on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void Paste(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.Paste();

}

}

/// <summary>

/// Execute Delete on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void Delete(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.Delete();

}

/// <summary>

/// Execute Delete on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void Delete(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.Delete();

}

}

/// <summary>

/// Execute SelectAll on the focused frame.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void SelectAll(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.SelectAll();

}

/// <summary>

/// Execute SelectAll on the focused frame.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void SelectAll(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.SelectAll();

}

}

/// <summary>

/// Opens up a new program window (using the default text editor) where the source code of the currently displayed web page is

/// shown.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

public static void ViewSource(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.ViewSource();

}

/// <summary>

/// Opens up a new program window (using the default text editor) where the source code of the currently displayed web page is

/// shown.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

public static void ViewSource(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.MainFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.ViewSource();

}

}

/// <summary>

/// Retrieve the main frame's HTML source using a <see cref="Task{String}"/>.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <returns>

/// <see cref="Task{String}"/> that when executed returns the main frame source as a string.

/// </returns>

public static Task<string> GetSourceAsync(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

return browser.BrowserCore.GetSourceAsync();

}

/// <summary>

/// Retrieve the main frame's HTML source using a <see cref="Task{String}"/>.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

/// <returns>

/// <see cref="Task{String}"/> that when executed returns the main frame source as a string.

/// </returns>

public static Task<string> GetSourceAsync(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

return frame.GetSourceAsync();

}

}

/// <summary>

/// Retrieve the main frame's display text using a <see cref="Task{String}"/>.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <returns>

/// <see cref="Task{String}"/> that when executed returns the main frame display text as a string.

/// </returns>

public static Task<string> GetTextAsync(this IChromiumWebBrowserBase browser)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

return browser.BrowserCore.GetTextAsync();

}

/// <summary>

/// Retrieve the main frame's display text using a <see cref="Task{String}"/>.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

/// <returns>

/// <see cref="Task{String}"/> that when executed returns the main frame display text as a string.

/// </returns>

public static Task<string> GetTextAsync(this IBrowser browser)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.FocusedFrame)

{

ThrowExceptionIfFrameNull(frame);

return frame.GetTextAsync();

}

}

/// <summary>

/// Download the file at url using <see cref="IDownloadHandler"/>.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="url">url to download</param>

public static void StartDownload(this IChromiumWebBrowserBase browser, string url)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.StartDownload(url);

}

/// <summary>

/// Download the file at url using <see cref="IDownloadHandler"/>.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

/// <param name="url">url to download</param>

public static void StartDownload(this IBrowser browser, string url)

{

ThrowExceptionIfBrowserNull(browser);

var host = browser.GetHost();

ThrowExceptionIfBrowserHostNull(host);

host.StartDownload(url);

}

/// <summary>

/// See <see cref="IChromiumWebBrowserBase.LoadUrlAsync(string)"/> for details

/// </summary>

/// <param name="chromiumWebBrowser">ChromiumWebBrowser instance (cannot be null)</param>

/// <summary>

/// Load the <paramref name="url"/> in the main frame of the browser

/// </summary>

/// <param name="url">url to load</param>

/// <returns>See <see cref="IChromiumWebBrowserBase.LoadUrlAsync(string)"/> for details</returns>

public static Task<LoadUrlAsyncResponse> LoadUrlAsync(IChromiumWebBrowserBase chromiumWebBrowser, string url)

{

ThrowExceptionIfChromiumWebBrowserDisposed(chromiumWebBrowser);

if (string.IsNullOrEmpty(url))

{

throw new ArgumentNullException(nameof(url));

}

var tcs = new TaskCompletionSource<LoadUrlAsyncResponse>(TaskCreationOptions.RunContinuationsAsynchronously);

EventHandler<LoadErrorEventArgs> loadErrorHandler = null;

EventHandler<LoadingStateChangedEventArgs> loadingStateChangeHandler = null;

loadErrorHandler = (sender, args) =>

{

//Actions that trigger a download will raise an aborted error.

//Generally speaking Aborted is safe to ignore

if (args.ErrorCode == CefErrorCode.Aborted)

{

return;

}

//If LoadError was called then we'll remove both our handlers

//as we won't need to capture LoadingStateChanged, we know there

//was an error

chromiumWebBrowser.LoadError -= loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged -= loadingStateChangeHandler;

tcs.TrySetResult(new LoadUrlAsyncResponse(args.ErrorCode, -1));

};

loadingStateChangeHandler = (sender, args) =>

{

//Wait for IsLoading = false

if (!args.IsLoading)

{

//If LoadingStateChanged was called then we'll remove both our handlers

//as LoadError won't be called, our site has loaded with a valid HttpStatusCode

//HttpStatusCodes can still be for example 404, this is considered a successful request,

//the server responded, it just didn't have the page you were after.

chromiumWebBrowser.LoadError -= loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged -= loadingStateChangeHandler;

var host = args.Browser.GetHost();

var navEntry = host?.GetVisibleNavigationEntry();

int statusCode = navEntry?.HttpStatusCode ?? -1;

//By default 0 is some sort of error, we map that to -1

//so that it's clearer that something failed.

if (statusCode == 0)

{

statusCode = -1;

}

tcs.TrySetResult(new LoadUrlAsyncResponse(statusCode == -1 ? CefErrorCode.Failed : CefErrorCode.None, statusCode));

}

};

chromiumWebBrowser.LoadError += loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged += loadingStateChangeHandler;

chromiumWebBrowser.LoadUrl(url);

return tcs.Task;

}

/// <summary>

/// This resolves when the browser navigates to a new URL or reloads.

/// It is useful for when you run code which will indirectly cause the browser to navigate.

/// A common use case would be when executing javascript that results in a navigation. e.g. clicks a link

/// This must be called before executing the action that navigates the browser. It may not resolve correctly

/// if called after.

/// </summary>

/// <remarks>

/// 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 navigation

/// </remarks>

/// <param name="chromiumWebBrowser">ChromiumWebBrowser instance (cannot be null)</param>

/// <param name="timeout">optional timeout, if not specified defaults to five(5) seconds.</param>

/// <param name="cancellationToken">optional CancellationToken</param>

/// <returns>Task which resolves when <see cref="IChromiumWebBrowserBase.LoadingStateChanged"/> has been called with <see cref="LoadingStateChangedEventArgs.IsLoading"/> false.

/// or when <see cref="IChromiumWebBrowserBase.LoadError"/> is called to signify a load failure.

/// </returns>

/// <example>

/// <code>

/// <![CDATA[

/// string script = "document.getElementsByTagName('a')[0].click();";

/// await Task.WhenAll(

/// chromiumWebBrowser.WaitForNavigationAsync(),

/// chromiumWebBrowser.EvaluateScriptAsync(script));

/// ]]>

/// </code>

/// </example>

public static async Task<WaitForNavigationAsyncResponse> WaitForNavigationAsync(IChromiumWebBrowserBase chromiumWebBrowser, TimeSpan? timeout = null, CancellationToken cancellationToken = default)

{

ThrowExceptionIfChromiumWebBrowserDisposed(chromiumWebBrowser);

var tcs = new TaskCompletionSource<WaitForNavigationAsyncResponse>(TaskCreationOptions.RunContinuationsAsynchronously);

EventHandler<LoadErrorEventArgs> loadErrorHandler = null;

EventHandler<LoadingStateChangedEventArgs> loadingStateChangeHandler = null;

loadErrorHandler = (sender, args) =>

{

//Actions that trigger a download will raise an aborted error.

//Generally speaking Aborted is safe to ignore

if (args.ErrorCode == CefErrorCode.Aborted)

{

return;

}

//If LoadError was called then we'll remove both our handlers

//as we won't need to capture LoadingStateChanged, we know there

//was an error

chromiumWebBrowser.LoadError -= loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged -= loadingStateChangeHandler;

tcs.TrySetResult(new WaitForNavigationAsyncResponse(args.ErrorCode, -1));

};

loadingStateChangeHandler = (sender, args) =>

{

//Wait for while page to finish loading not just the first frame

if (!args.IsLoading)

{

//If LoadingStateChanged was called then we'll remove both our handlers

//as LoadError won't be called, our site has loaded with a valid HttpStatusCode

//HttpStatusCodes can still be for example 404, this is considered a successful request,

//the server responded, it just didn't have the page you were after.

chromiumWebBrowser.LoadError -= loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged -= loadingStateChangeHandler;

var host = args.Browser.GetHost();

var navEntry = host?.GetVisibleNavigationEntry();

int statusCode = navEntry?.HttpStatusCode ?? -1;

//By default 0 is some sort of error, we map that to -1

//so that it's clearer that something failed.

if (statusCode == 0)

{

statusCode = -1;

}

tcs.TrySetResult(new WaitForNavigationAsyncResponse(statusCode == -1 ? CefErrorCode.Failed : CefErrorCode.None, statusCode));

}

};

chromiumWebBrowser.LoadError += loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged += loadingStateChangeHandler;

try

{

return await TaskTimeoutExtensions.WaitAsync(tcs.Task, timeout ?? TimeSpan.FromSeconds(5), cancellationToken).ConfigureAwait(false);

}

catch (Exception)

{

chromiumWebBrowser.LoadError -= loadErrorHandler;

chromiumWebBrowser.LoadingStateChanged -= loadingStateChangeHandler;

throw;

}

}

/// <summary>

/// Waits for a DOM element specified by the <paramref name="selector"/> string to be added to or removed from the DOM.

/// A simplified version of Puppeteer WaitForSelector. Uses a MutationObserver to wait for the element to become added or removed.

/// </summary>

/// <param name="chromiumWebBrowser">ChromiumWebBrowser instance (cannot be null)</param>

/// <param name="selector">querySelector for the element e.g. #idOfMyElement</param>

/// <param name="timeout">timeout</param>

/// <param name="removed">

/// (Optional) if true waits for element to be removed from the DOM. If the querySelector immediately resolves

/// to null then the element is considered removed. If false (default) waits for the element to be added to the DOM.

/// </param>

/// <returns>A Task that resolves when element specified by selector string is added to or removed from the DOM.</returns>

/// <example>

/// <code>

/// <![CDATA[

/// string script = "const newDiv = document.createElement('div'); newDiv.id = 'myElement'; document.body.append(newDiv);";

/// await Task.WhenAll(

/// browser.WaitForSelectorAsync("#myElement");,

/// chromiumWebBrowser.EvaluateScriptAsync(script));

/// ]]>

/// </code>

/// </example>

/// <remarks>

/// This function is typically used in conjunction with javascript that directly or indirectly adds/removes an element from the DOM.

/// Unlike the puppeteer version navigations aren't handled internally, the method will throw a <see cref="TimeoutException"/> if a navigation

/// occurs whilst waiting to resolve.

/// </remarks>

public static async Task<WaitForSelectorAsyncResponse> WaitForSelectorAsync(this IWebBrowser chromiumWebBrowser, string selector, TimeSpan? timeout = null, bool removed = false)

{

const string waitForSelectorFunction = @"

async function waitForSelectorFunction(timeout, selector, waitForRemoved)

{

let timedOut = false;

if (timeout)

setTimeout(() => (timedOut = true), timeout);

return await pollMutation();

async function pollMutation() {

const success = await mutationSelector(selector, waitForRemoved);

if (success)

return Promise.resolve(success);

let fulfill;

const result = new Promise((x) => (fulfill = x));

const observer = new MutationObserver(async () => {

if (timedOut) {

observer.disconnect();

fulfill();

}

const success = await mutationSelector(selector, waitForRemoved);

if (success) {

observer.disconnect();

fulfill(success);

}

});

observer.observe(document, {

childList: true,

subtree: true,

attributes: false,

});

return result;

}

async function mutationSelector(selector, waitForRemoved)

{

const element = document.querySelector(selector);

if (!element)

return waitForRemoved;

if(waitForRemoved && element)

return null;

let obj = {};

obj.id = element.id;

obj.nodeValue = element.nodeValue;

obj.localName = element.localName;

obj.tagName = element.tagName;

return obj;

}

};";

if(chromiumWebBrowser == null)

{

throw new ArgumentNullException(nameof(chromiumWebBrowser));

}

if(string.IsNullOrEmpty(selector))

{

throw new ArgumentException($"{nameof(selector)} cannot be null or empty.");

}

var execute = GetScriptForJavascriptMethodWithArgs("waitForSelectorFunction", new object[] { timeout.HasValue ? timeout.Value.Milliseconds : 5000, selector, removed });

var query = @"return (async () => {" + Environment.NewLine + waitForSelectorFunction + Environment.NewLine + "return " + execute + Environment.NewLine + "})(); ";

var response = chromiumWebBrowser.EvaluateScriptAsPromiseAsync(query);

var timeoutResponse = await TaskTimeoutExtensions.WaitAsync(response, timeout ?? TimeSpan.FromSeconds(5)).ConfigureAwait(continueOnCapturedContext:false);

if(timeoutResponse.Success)

{

if(removed)

{

if ((bool)timeoutResponse.Result)

{

return new WaitForSelectorAsyncResponse(string.Empty, string.Empty, false);

}

return new WaitForSelectorAsyncResponse(false, $"Failed to detect DOM change for removed element via selector {selector}");

}

var element = (IDictionary<string, object>)timeoutResponse.Result;

var id = element["id"].ToString();

var tagName = element["tagName"].ToString();

return new WaitForSelectorAsyncResponse(id, tagName, true);

}

return new WaitForSelectorAsyncResponse(false, timeoutResponse.Message);

}

/// <summary>

/// Execute Javascript code in the context of this Browser. As the method name implies, the script will be executed

/// asynchronously, and the method therefore returns before the script has actually been executed. This simple helper extension

/// will encapsulate params in single quotes (unless int, uint, etc)

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="methodName">The javascript method name to execute.</param>

/// <param name="args">the arguments to be passed as params to the method. Args are encoded using

/// <see cref="EncodeScriptParam"/>, you can provide a custom implementation if you require one.</param>

public static void ExecuteScriptAsync(this IChromiumWebBrowserBase browser, string methodName, params object[] args)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.ExecuteScriptAsync(methodName, args);

}

/// <summary>

/// Execute Javascript code in the context of this WebBrowser. As the method name implies, the script will be executed

/// asynchronously, and the method therefore returns before the script has actually been executed. This simple helper extension

/// will encapsulate params in single quotes (unless int, uint, etc)

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

/// <param name="methodName">The javascript method name to execute.</param>

/// <param name="args">the arguments to be passed as params to the method. Args are encoded using

/// <see cref="EncodeScriptParam"/>, you can provide a custom implementation if you require one.</param>

public static void ExecuteScriptAsync(this IBrowser browser, string methodName, params object[] args)

{

ThrowExceptionIfBrowserNull(browser);

var script = GetScriptForJavascriptMethodWithArgs(methodName, args);

browser.ExecuteScriptAsync(script);

}

/// <summary>

/// Execute Javascript in the context of this Browsers Main Frame. As the method name implies, the script will be executed

/// asynchronously, and the method therefore returns before the script has actually been executed.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="script">The Javascript code that should be executed.</param>

public static void ExecuteScriptAsync(this IChromiumWebBrowserBase browser, string script)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

using (var frame = browser.GetMainFrame())

{

ThrowExceptionIfFrameNull(frame);

frame.ExecuteJavaScriptAsync(script);

}

}

/// <summary>

/// Execute Javascript in the context of this Browser Main Frame. As the method name implies, the script will be executed

/// asynchronously, and the method therefore returns before the script has actually been executed.

/// </summary>

/// <param name="browser">The IBrowser instance this method extends.</param>

/// <param name="script">The Javascript code that should be executed.</param>

public static void ExecuteScriptAsync(this IBrowser browser, string script)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.MainFrame)

{

ThrowExceptionIfFrameNull(frame);

frame.ExecuteJavaScriptAsync(script);

}

}

/// <summary>

/// Execute Javascript code in the context of this Browsers Main Frame. This extension method uses the LoadingStateChanged event. As the

/// method name implies, the script will be executed asynchronously, and the method therefore returns before the script has

/// actually been executed.

/// </summary>

/// <remarks>

/// Best effort is made to make sure the script is executed, there are likely a few edge cases where the script won't be executed,

/// if you suspect your script isn't being executed, then try executing in the LoadingStateChanged event handler to confirm that

/// it does indeed get executed.

/// </remarks>

/// <param name="webBrowser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="script">The Javascript code that should be executed.</param>

/// <param name="oneTime">(Optional) The script will only be executed on first page load, subsequent page loads will be ignored.</param>

public static void ExecuteScriptAsyncWhenPageLoaded(this IChromiumWebBrowserBase webBrowser, string script, bool oneTime = true)

{

ThrowExceptionIfChromiumWebBrowserDisposed(webBrowser);

var useLoadingStateChangedEventHandler = webBrowser.IsBrowserInitialized == false || oneTime == false;

//Browser has been initialized, we check if there is a valid document and we're not loading

if (webBrowser.IsBrowserInitialized)

{

//CefBrowser wrapper

var browser = webBrowser.BrowserCore;

if (browser.HasDocument && browser.IsLoading == false)

{

webBrowser.ExecuteScriptAsync(script);

}

else

{

useLoadingStateChangedEventHandler = true;

}

}

//If the browser hasn't been initialized we can just wire up the LoadingStateChanged event

//If the script has already been executed and oneTime is false will be hooked up next page load.

if (useLoadingStateChangedEventHandler)

{

EventHandler<LoadingStateChangedEventArgs> handler = null;

handler = (sender, args) =>

{

//Wait for while page to finish loading not just the first frame

if (!args.IsLoading)

{

if (oneTime)

{

webBrowser.LoadingStateChanged -= handler;

}

webBrowser.ExecuteScriptAsync(script);

}

};

webBrowser.LoadingStateChanged += handler;

}

}

/// <summary>

/// Creates a new instance of IRequest with the specified Url and Method = POST and then calls

/// <see cref="IFrame.LoadRequest(IRequest)"/>.

/// </summary>

/// <param name="browser">browser this method extends</param>

/// <param name="url">url to load</param>

/// <param name="postDataBytes">post data as byte array</param>

/// <param name="contentType">(Optional) if set the Content-Type header will be set</param>

public static void LoadUrlWithPostData(this IChromiumWebBrowserBase browser, string url, byte[] postDataBytes, string contentType = null)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

browser.BrowserCore.LoadUrlWithPostData(url, postDataBytes, contentType);

}

/// <summary>

/// Creates a new instance of IRequest with the specified Url and Method = POST and then calls

/// <see cref="IFrame.LoadRequest(IRequest)"/>.

/// </summary>

/// <param name="browser">browser this method extends</param>

/// <param name="url">url to load</param>

/// <param name="postDataBytes">post data as byte array</param>

/// <param name="contentType">(Optional) if set the Content-Type header will be set</param>

public static void LoadUrlWithPostData(this IBrowser browser, string url, byte[] postDataBytes, string contentType = null)

{

ThrowExceptionIfBrowserNull(browser);

using (var frame = browser.MainFrame)

{

ThrowExceptionIfFrameNull(frame);

//Initialize Request with PostData

var request = frame.CreateRequest(initializePostData: true);

request.Url = url;

request.Method = "POST";

//Add AllowStoredCredentials as per suggestion linked in

//https://github.com/cefsharp/CefSharp/issues/2705#issuecomment-476819788

request.Flags = UrlRequestFlags.AllowStoredCredentials;

request.PostData.AddData(postDataBytes);

if (!string.IsNullOrEmpty(contentType))

{

var headers = new NameValueCollection();

headers.Add("Content-Type", contentType);

request.Headers = headers;

}

frame.LoadRequest(request);

}

}

/// <summary>

/// Registers and loads a <see cref="ResourceHandler"/> that represents the HTML content.

/// </summary>

/// <remarks>

/// `Cef` Native `LoadHtml` is unpredictable and only works sometimes, this method wraps the provided HTML in a

/// <see cref="ResourceHandler"/> and loads the provided url using the <see cref="IWebBrowser.Load"/> method. Defaults to using

/// <see cref="Encoding.UTF8"/> for character encoding The url must start with a valid schema, other uri's such as about:blank

/// are invalid A valid example looks like http://test/page.

/// </remarks>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="html">The HTML content.</param>

/// <param name="url">The URL that will be treated as the address of the content.</param>

/// <returns>

/// returns false if the Url was not successfully parsed into a Uri.

/// </returns>

public static bool LoadHtml(this IWebBrowser browser, string html, string url)

{

return browser.LoadHtml(html, url, Encoding.UTF8);

}

/// <summary>

/// Loads html as Data Uri See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs for details If

/// base64Encode is false then html will be Uri encoded.

/// </summary>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="html">Html to load as data uri.</param>

/// <param name="base64Encode">(Optional) if true the html string will be base64 encoded using UTF8 encoding.</param>

public static void LoadHtml(this IChromiumWebBrowserBase browser, string html, bool base64Encode = false)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

var htmlString = new HtmlString(html, base64Encode);

browser.LoadUrl(htmlString.ToDataUriString());

}

/// <summary>

/// Loads html as Data Uri See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs for details If

/// base64Encode is false then html will be Uri encoded.

/// </summary>

/// <param name="frame">The <seealso cref="IFrame"/> instance this method extends.</param>

/// <param name="html">Html to load as data uri.</param>

/// <param name="base64Encode">(Optional) if true the html string will be base64 encoded using UTF8 encoding.</param>

public static void LoadHtml(this IFrame frame, string html, bool base64Encode = false)

{

var htmlString = new HtmlString(html, base64Encode);

frame.LoadUrl(htmlString.ToDataUriString());

}

/// <summary>

/// Registers and loads a <see cref="ResourceHandler"/> that represents the HTML content.

/// </summary>

/// <remarks>

/// `Cef` Native `LoadHtml` is unpredictable and only works sometimes, this method wraps the provided HTML in a

/// <see cref="ResourceHandler"/> and loads the provided url using the <see cref="IWebBrowser.Load"/> method.

/// </remarks>

/// <exception cref="Exception">Thrown when an exception error condition occurs.</exception>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="html">The HTML content.</param>

/// <param name="url">The URL that will be treated as the address of the content.</param>

/// <param name="encoding">Character Encoding.</param>

/// <param name="oneTimeUse">(Optional) Whether or not the handler should be used once (true) or until manually unregistered

/// (false)</param>

/// <returns>

/// returns false if the Url was not successfully parsed into a Uri.

/// </returns>

public static bool LoadHtml(this IWebBrowser browser, string html, string url, Encoding encoding, bool oneTimeUse = false)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

if (browser.ResourceRequestHandlerFactory == null)

{

browser.ResourceRequestHandlerFactory = new ResourceRequestHandlerFactory();

}

var handler = browser.ResourceRequestHandlerFactory as ResourceRequestHandlerFactory;

if (handler == null)

{

throw new Exception("LoadHtml can only be used with the default IResourceRequestHandlerFactory(DefaultResourceRequestHandlerFactory) implementation");

}

if (handler.RegisterHandler(url, ResourceHandler.GetByteArray(html, encoding, true), ResourceHandler.DefaultMimeType, oneTimeUse))

{

browser.Load(url);

return true;

}

return false;

}

/// <summary>

/// Register a ResourceHandler. Can only be used when browser.ResourceHandlerFactory is an instance of

/// DefaultResourceHandlerFactory.

/// </summary>

/// <exception cref="Exception">Thrown when an exception error condition occurs.</exception>

/// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>

/// <param name="url">the url of the resource to unregister.</param>

/// <param name="stream">Stream to be registered, the stream should not be shared with any other instances of

/// DefaultResourceHandlerFactory.</param>

/// <param name="mimeType">(Optional) the mimeType.</param>

/// <param name="oneTimeUse">(Optional) Whether or not the handler should be used once (true) or until manually unregistered

/// (false). If true the Stream will be Diposed of when finished.</param>

public static void RegisterResourceHandler(this IWebBrowser browser, string url, Stream stream, string mimeType = ResourceHandler.DefaultMimeType,

bool oneTimeUse = false)

{

ThrowExceptionIfChromiumWebBrowserDisposed(browser);

if (browser.ResourceRequestHandlerFactory == null)

{

browser.ResourceRequestHandlerFactory = new ResourceRequestHandlerFactory();

}