WebBrowserExtensionsEx.cs

// Copyright © 2021 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 CefSharp.Internals;
using CefSharp.ModelBinding;
using System;
using System.IO;
using System.Threading.Tasks;

namespace CefSharp
{
    /// <summary>
    /// Extended WebBrowserExtensions
    /// </summary>
    public static class WebBrowserExtensionsEx
    {
        /// <summary>
        /// Retrieve the current <see cref="NavigationEntry"/>. Contains information like
        /// <see cref="NavigationEntry.HttpStatusCode"/> and <see cref="NavigationEntry.SslStatus"/>
        /// </summary>
        /// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>
        /// <returns>
        /// <see cref="Task{NavigationEntry}"/> that when executed returns the current <see cref="NavigationEntry"/> or null
        /// </returns>
        public static Task<NavigationEntry> GetVisibleNavigationEntryAsync(this IChromiumWebBrowserBase browser)
        {
            var host = browser.GetBrowserHost();

            if (host == null)
            {
                return Task.FromResult<NavigationEntry>(null);
            }

            if(Cef.CurrentlyOnThread(CefThreadIds.TID_UI))
            {
                var entry = host.GetVisibleNavigationEntry();

                return Task.FromResult<NavigationEntry>(entry);
            }

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

            Cef.UIThreadTaskFactory.StartNew(delegate
            {
                var entry = host.GetVisibleNavigationEntry();

                tcs.TrySetResult(entry);
            });

            return tcs.Task;
        }

        /// <summary>
        /// Downloads the specified <paramref name="url"/> and calls <paramref name="completeHandler"/>
        /// when the download is complete. Makes a GET Request.
        /// </summary>
        /// <param name="frame">valid frame</param>
        /// <param name="url">url to download</param>
        /// <param name="completeHandler">Action to be executed when the download is complete.</param>
        public static void DownloadUrl(this IFrame frame, string url, Action<IUrlRequest, Stream>  completeHandler)
        {
            if (!frame.IsValid)
            {
                throw new Exception("Frame is invalid, unable to continue.");
            }

            //Can be created on any valid CEF Thread, here we'll use the CEF UI Thread
            Cef.UIThreadTaskFactory.StartNew(delegate
            {
                var request = frame.CreateRequest(false);

                request.Method = "GET";
                request.Url = url;

                var memoryStream = new MemoryStream();

                var urlRequestClient = Fluent.UrlRequestClient
                    .Create()
                    .OnDownloadData((req, stream) =>
                    {
                        stream.CopyTo(memoryStream);
                    })
                    .OnRequestComplete((req) =>
                    {
                        memoryStream.Position = 0;

                        completeHandler?.Invoke(req, memoryStream);
                    })
                    .Build();

                var urlRequest = frame.CreateUrlRequest(request, urlRequestClient);
            });
        }

        /// <summary>
        /// Downloads the specified <paramref name="url"/> as a <see cref="T:byte[]"/>.
        /// Makes a GET Request.
        /// </summary>
        /// <param name="frame">valid frame</param>
        /// <param name="url">url to download</param>
        /// <param name="urlRequestFlags">control caching policy</param>
        /// <returns>A task that can be awaited to get the <see cref="T:byte[]"/> representing the Url</returns>
        public static Task<byte[]> DownloadUrlAsync(this IFrame frame, string url, UrlRequestFlags urlRequestFlags = UrlRequestFlags.None)
        {
            if (frame == null)
            {
                throw new ArgumentNullException(nameof(frame));
            }

            if (!frame.IsValid)
            {
                throw new Exception("Frame is invalid, unable to continue.");
            }

            var taskCompletionSource = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);

            //Can be created on any valid CEF Thread, here we'll use the CEF UI Thread
            Cef.UIThreadTaskFactory.StartNew(delegate
            {
                var request = frame.CreateRequest(false);

                request.Method = "GET";
                request.Url = url;
                request.Flags = urlRequestFlags;

                var memoryStream = new MemoryStream();

                var urlRequestClient = Fluent.UrlRequestClient
                    .Create()
                    .OnDownloadData((req, stream) =>
                    {
                        stream.CopyTo(memoryStream);
                    })
                    .OnRequestComplete((req) =>
                    {
                        if (req.RequestStatus == UrlRequestStatus.Success)
                        {
                            taskCompletionSource.TrySetResult(memoryStream.ToArray());
                        }
                        else
                        {
                            taskCompletionSource.TrySetException(new Exception("RequestStatus:" + req.RequestStatus + ";StatusCode:" + req.Response.StatusCode));
                        }
                    })
                    .Build();

                var urlRequest = frame.CreateUrlRequest(request, urlRequestClient);
            });

            return taskCompletionSource.Task;
        }

        /// <summary>
        /// Toggles audio mute for the current browser.
        /// If the <paramref name="browser"/> is null or has been disposed
        /// then this command will be a no-op.
        /// </summary>
        /// <param name="browser">The ChromiumWebBrowser instance this method extends.</param>
        public static void ToggleAudioMute(this IChromiumWebBrowserBase browser)
        {
            if (browser.IsDisposed || Cef.IsShutdown)
            {
                return;
            }

            _ = Cef.UIThreadTaskFactory.StartNew(delegate
            {
                var cefBrowser = browser.BrowserCore;

                if (cefBrowser == null || cefBrowser.IsDisposed)
                {
                    return;
                }

                var host = cefBrowser.GetHost();

                var isAudioMuted = host.IsAudioMuted;

                host.SetAudioMuted(!isAudioMuted);
            });
        }

        /// <summary>
        /// Evaluate javascript code in the context of the <paramref name="frame"/>. The script will be executed
        /// asynchronously and the method returns a Task that can be awaited to obtain the result.
        /// </summary>
        /// <typeparam name="T">Type</typeparam>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when one or more arguments are outside the required range.</exception>
        /// <exception cref="Exception">Thrown if a Javascript error occurs.</exception>
        /// <param name="frame">The IFrame instance this method extends.</param>
        /// <param name="script">The Javascript code that should be executed.</param>
        /// <param name="timeout">(Optional) The timeout after which the Javascript code execution should be aborted.</param>
        /// <returns>
        /// <see cref="Task{T}"/> that can be awaited to obtain the result of the script execution. The <see cref="ModelBinding.DefaultBinder"/>
        /// is used to convert the result to the desired type. Property names are converted from camelCase.
        /// If the script execution returns an error then an exception is thrown.
        /// </returns>
        public static async Task<T> EvaluateScriptAsync<T>(this IFrame frame, string script, TimeSpan? timeout = null)
        {
            WebBrowserExtensions.ThrowExceptionIfFrameNull(frame);

            if (timeout.HasValue && timeout.Value.TotalMilliseconds > uint.MaxValue)
            {
                throw new ArgumentOutOfRangeException("timeout", "Timeout greater than Maximum allowable value of " + UInt32.MaxValue);
            }           

            var response = await frame.EvaluateScriptAsync(script, timeout: timeout, useImmediatelyInvokedFuncExpression: false).ConfigureAwait(false);

            if (response.Success)
            {
                var binder = DefaultBinder.Instance;

                return (T)binder.Bind(response.Result, typeof(T));
            }

            throw new Exception(response.Message);
        }

        /// <summary>
        /// Evaluate some Javascript code in the context of the MainFrame of the ChromiumWebBrowser. The script will be executed
        /// asynchronously and the method returns a Task encapsulating the response from the Javascript
        /// </summary>
        /// <typeparam name="T">Type</typeparam>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when one or more arguments are outside the required range.</exception>
        /// <param name="browser">The IBrowser instance this method extends.</param>
        /// <param name="script">The JavaScript code that should be executed.</param>
        /// <param name="timeout">(Optional) The timeout after which the JavaScript code execution should be aborted.</param>
        /// <returns>
        /// <see cref="Task{T}"/> that can be awaited to obtain the result of the JavaScript execution.
        /// </returns>
        public static Task<T> EvaluateScriptAsync<T>(this IBrowser browser, string script, TimeSpan? timeout = null)
        {
            WebBrowserExtensions.ThrowExceptionIfBrowserNull(browser);

            using (var frame = browser.MainFrame)
            {
                return frame.EvaluateScriptAsync<T>(script, timeout: timeout);
            }
        }

        /// <summary>
        /// Evaluate Javascript in the context of this Browsers Main Frame. The script will be executed
        /// asynchronously and the method returns a Task encapsulating the response from the Javascript
        /// </summary>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when one or more arguments are outside the required range.</exception>
        /// <typeparam name="T">Type</typeparam>
        /// <param name="chromiumWebBrowser">The ChromiumWebBrowser instance this method extends.</param>
        /// <param name="script">The Javascript code that should be executed.</param>
        /// <param name="timeout">(Optional) The timeout after which the Javascript code execution should be aborted.</param>
        /// <returns>
        /// <see cref="Task{T}"/> that can be awaited to obtain the result of the script execution.
        /// </returns>
        public static Task<T> EvaluateScriptAsync<T>(this IChromiumWebBrowserBase chromiumWebBrowser, string script, TimeSpan? timeout = null)
        {
            WebBrowserExtensions.ThrowExceptionIfChromiumWebBrowserDisposed(chromiumWebBrowser);

            if (chromiumWebBrowser is IWebBrowser b)
            {
                if (b.CanExecuteJavascriptInMainFrame == false)
                {
                    WebBrowserExtensions.ThrowExceptionIfCanExecuteJavascriptInMainFrameFalse();
                }
            }

            return chromiumWebBrowser.BrowserCore.EvaluateScriptAsync<T>(script, timeout);
        }
    }
}