| // <copyright file="ChromiumOptions.cs" company="Selenium Committers"> | |
| // Licensed to the Software Freedom Conservancy (SFC) under one | |
| // or more contributor license agreements. See the NOTICE file | |
| // distributed with this work for additional information | |
| // regarding copyright ownership. The SFC licenses this file | |
| // to you under the Apache License, Version 2.0 (the | |
| // "License"); you may not use this file except in compliance | |
| // with the License. You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, | |
| // software distributed under the License is distributed on an | |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| // KIND, either express or implied. See the License for the | |
| // specific language governing permissions and limitations | |
| // under the License. | |
| // </copyright> | |
| using System.Collections.ObjectModel; | |
| namespace OpenQA.Selenium.Chromium; | |
| /// <summary> | |
| /// Abstract class to manage options specific to Chromium-based browsers. | |
| /// </summary> | |
| public abstract class ChromiumOptions : DriverOptions | |
| { | |
| private const string ArgumentsChromeOption = "args"; | |
| private const string BinaryChromeOption = "binary"; | |
| private const string ExtensionsChromeOption = "extensions"; | |
| private const string LocalStateChromeOption = "localState"; | |
| private const string PreferencesChromeOption = "prefs"; | |
| private const string DetachChromeOption = "detach"; | |
| private const string DebuggerAddressChromeOption = "debuggerAddress"; | |
| private const string ExcludeSwitchesChromeOption = "excludeSwitches"; | |
| private const string MinidumpPathChromeOption = "minidumpPath"; | |
| private const string MobileEmulationChromeOption = "mobileEmulation"; | |
| private const string PerformanceLoggingPreferencesChromeOption = "perfLoggingPrefs"; | |
| private const string WindowTypesChromeOption = "windowTypes"; | |
| private const string UseSpecCompliantProtocolOption = "w3c"; | |
| private readonly bool useSpecCompliantProtocol = true; | |
| private readonly List<string> arguments = new List<string>(); | |
| private readonly List<string> extensionFiles = new List<string>(); | |
| private readonly List<string> encodedExtensions = new List<string>(); | |
| private readonly List<string> excludedSwitches = new List<string>(); | |
| private readonly List<string> windowTypes = new List<string>(); | |
| private readonly Dictionary<string, object> additionalChromeOptions = new Dictionary<string, object>(); | |
| private Dictionary<string, object>? userProfilePreferences; | |
| private Dictionary<string, object>? localStatePreferences; | |
| private string? mobileEmulationDeviceName; | |
| private ChromiumMobileEmulationDeviceSettings? mobileEmulationDeviceSettings; | |
| /// <summary> | |
| /// Initializes a new instance of the <see cref="ChromiumOptions"/> class. | |
| /// </summary> | |
| public ChromiumOptions() : base() | |
| { | |
| this.AddKnownCapabilityName(this.CapabilityName, "current ChromiumOptions class instance"); | |
| this.AddKnownCapabilityName(CapabilityType.LoggingPreferences, "SetLoggingPreference method"); | |
| this.AddKnownCapabilityName(this.LoggingPreferencesChromeOption, "SetLoggingPreference method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.ArgumentsChromeOption, "AddArguments method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.BinaryChromeOption, "BinaryLocation property"); | |
| this.AddKnownCapabilityName(ChromiumOptions.ExtensionsChromeOption, "AddExtensions method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.LocalStateChromeOption, "AddLocalStatePreference method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.PreferencesChromeOption, "AddUserProfilePreference method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.DetachChromeOption, "LeaveBrowserRunning property"); | |
| this.AddKnownCapabilityName(ChromiumOptions.DebuggerAddressChromeOption, "DebuggerAddress property"); | |
| this.AddKnownCapabilityName(ChromiumOptions.ExcludeSwitchesChromeOption, "AddExcludedArgument property"); | |
| this.AddKnownCapabilityName(ChromiumOptions.MinidumpPathChromeOption, "MinidumpPath property"); | |
| this.AddKnownCapabilityName(ChromiumOptions.MobileEmulationChromeOption, "EnableMobileEmulation method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.PerformanceLoggingPreferencesChromeOption, "PerformanceLoggingPreferences property"); | |
| this.AddKnownCapabilityName(ChromiumOptions.WindowTypesChromeOption, "AddWindowTypes method"); | |
| this.AddKnownCapabilityName(ChromiumOptions.UseSpecCompliantProtocolOption, "UseSpecCompliantProtocol property"); | |
| } | |
| /// <summary> | |
| /// Gets the vendor prefix to apply to Chromium-specific capability names. | |
| /// </summary> | |
| protected abstract string VendorPrefix { get; } | |
| private string LoggingPreferencesChromeOption => this.VendorPrefix + ":loggingPrefs"; | |
| /// <summary> | |
| /// Gets the name of the capability used to store Chromium options in | |
| /// an <see cref="ICapabilities"/> object. | |
| /// </summary> | |
| public abstract string CapabilityName { get; } | |
| /// <summary> | |
| /// Gets or sets the location of the Chromium browser's binary executable file. | |
| /// </summary> | |
| public override string? BinaryLocation { get; set; } | |
| /// <summary> | |
| /// Gets or sets a value indicating whether Chromium should be left running after the | |
| /// ChromeDriver instance is exited. Defaults to <see langword="false"/>. | |
| /// </summary> | |
| public bool LeaveBrowserRunning { get; set; } | |
| /// <summary> | |
| /// Gets the list of arguments appended to the Chromium command line as a string array. | |
| /// </summary> | |
| public ReadOnlyCollection<string> Arguments => this.arguments.AsReadOnly(); | |
| /// <summary> | |
| /// Gets the list of extensions to be installed as an array of base64-encoded strings. | |
| /// </summary> | |
| public ReadOnlyCollection<string> Extensions | |
| { | |
| get | |
| { | |
| List<string> allExtensions = new List<string>(this.encodedExtensions); | |
| foreach (string extensionFile in this.extensionFiles) | |
| { | |
| byte[] extensionByteArray = File.ReadAllBytes(extensionFile); | |
| string encodedExtension = Convert.ToBase64String(extensionByteArray); | |
| allExtensions.Add(encodedExtension); | |
| } | |
| return allExtensions.AsReadOnly(); | |
| } | |
| } | |
| /// <summary> | |
| /// Gets or sets the address of a Chromium debugger server to connect to. | |
| /// Should be of the form "{hostname|IP address}:port". | |
| /// </summary> | |
| public string? DebuggerAddress { get; set; } | |
| /// <summary> | |
| /// Gets or sets the directory in which to store minidump files. | |
| /// </summary> | |
| public string? MinidumpPath { get; set; } | |
| /// <summary> | |
| /// Gets or sets the performance logging preferences for the driver. | |
| /// </summary> | |
| public ChromiumPerformanceLoggingPreferences? PerformanceLoggingPreferences { get; set; } | |
| /// <summary> | |
| /// Gets or sets the options for automating Chromium applications on Android. | |
| /// </summary> | |
| public ChromiumAndroidOptions? AndroidOptions { get; set; } | |
| /// <summary> | |
| /// Adds a single argument to the list of arguments to be appended to the browser executable command line. | |
| /// </summary> | |
| /// <param name="argument">The argument to add.</param> | |
| /// <exception cref="ArgumentException">If <paramref name="argument"/> is <see langword="null"/> or <see cref="string.Empty"/>.</exception> | |
| public void AddArgument(string argument) | |
| { | |
| if (string.IsNullOrEmpty(argument)) | |
| { | |
| throw new ArgumentException("argument must not be null or empty", nameof(argument)); | |
| } | |
| this.AddArguments(argument); | |
| } | |
| /// <summary> | |
| /// Adds arguments to be appended to the browser executable command line. | |
| /// </summary> | |
| /// <param name="argumentsToAdd">An array of arguments to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="argumentsToAdd"/> is <see langword="null"/>.</exception> | |
| public void AddArguments(params string[] argumentsToAdd) | |
| { | |
| this.AddArguments((IEnumerable<string>)argumentsToAdd); | |
| } | |
| /// <summary> | |
| /// Adds arguments to be appended to the browser executable command line. | |
| /// </summary> | |
| /// <param name="argumentsToAdd">An <see cref="IEnumerable{T}"/> object of arguments to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="argumentsToAdd"/> is <see langword="null"/>.</exception> | |
| public void AddArguments(IEnumerable<string> argumentsToAdd) | |
| { | |
| if (argumentsToAdd == null) | |
| { | |
| throw new ArgumentNullException(nameof(argumentsToAdd), "argumentsToAdd must not be null"); | |
| } | |
| this.arguments.AddRange(argumentsToAdd); | |
| } | |
| /// <summary> | |
| /// Adds a single argument to be excluded from the list of arguments passed by default | |
| /// to the browser executable command line by chromedriver.exe. | |
| /// </summary> | |
| /// <param name="argument">The argument to exclude.</param> | |
| /// <exception cref="ArgumentException">If <paramref name="argument"/> is <see langword="null"/> or <see cref="string.Empty"/>.</exception> | |
| public void AddExcludedArgument(string argument) | |
| { | |
| if (string.IsNullOrEmpty(argument)) | |
| { | |
| throw new ArgumentException("argument must not be null or empty", nameof(argument)); | |
| } | |
| this.AddExcludedArguments(argument); | |
| } | |
| /// <summary> | |
| /// Adds arguments to be excluded from the list of arguments passed by default | |
| /// to the browser executable command line by chromedriver.exe. | |
| /// </summary> | |
| /// <param name="argumentsToExclude">An array of arguments to exclude.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="argumentsToExclude"/> is <see langword="null"/>.</exception> | |
| public void AddExcludedArguments(params string[] argumentsToExclude) | |
| { | |
| this.AddExcludedArguments((IEnumerable<string>)argumentsToExclude); | |
| } | |
| /// <summary> | |
| /// Adds arguments to be excluded from the list of arguments passed by default | |
| /// to the browser executable command line by chromedriver.exe. | |
| /// </summary> | |
| /// <param name="argumentsToExclude">An <see cref="IEnumerable{T}"/> object of arguments to exclude.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="argumentsToExclude"/> is <see langword="null"/>.</exception> | |
| public void AddExcludedArguments(IEnumerable<string> argumentsToExclude) | |
| { | |
| if (argumentsToExclude == null) | |
| { | |
| throw new ArgumentNullException(nameof(argumentsToExclude), "argumentsToExclude must not be null"); | |
| } | |
| this.excludedSwitches.AddRange(argumentsToExclude); | |
| } | |
| /// <summary> | |
| /// Adds a path to a packed Chrome extension (.crx file) to the list of extensions | |
| /// to be installed in the instance of Chrome. | |
| /// </summary> | |
| /// <param name="pathToExtension">The full path to the extension to add.</param> | |
| /// <exception cref="ArgumentException">If <paramref name="pathToExtension"/> is <see langword="null"/> or <see cref="string.Empty"/>.</exception> | |
| public void AddExtension(string pathToExtension) | |
| { | |
| if (string.IsNullOrEmpty(pathToExtension)) | |
| { | |
| throw new ArgumentException("pathToExtension must not be null or empty", nameof(pathToExtension)); | |
| } | |
| this.AddExtensions(pathToExtension); | |
| } | |
| /// <summary> | |
| /// Adds a list of paths to packed Chrome extensions (.crx files) to be installed | |
| /// in the instance of Chrome. | |
| /// </summary> | |
| /// <param name="extensions">An array of full paths to the extensions to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="extensions"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="FileNotFoundException">If any extension file path does not point to a file.</exception> | |
| public void AddExtensions(params string[] extensions) | |
| { | |
| this.AddExtensions((IEnumerable<string>)extensions); | |
| } | |
| /// <summary> | |
| /// Adds a list of paths to packed Chrome extensions (.crx files) to be installed | |
| /// in the instance of Chrome. | |
| /// </summary> | |
| /// <param name="extensions">An <see cref="IEnumerable{T}"/> of full paths to the extensions to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="extensions"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="FileNotFoundException">If any extension file path does not point to a file.</exception> | |
| public void AddExtensions(IEnumerable<string> extensions) | |
| { | |
| if (extensions == null) | |
| { | |
| throw new ArgumentNullException(nameof(extensions), "extensions must not be null"); | |
| } | |
| foreach (string extension in extensions) | |
| { | |
| if (!File.Exists(extension)) | |
| { | |
| throw new FileNotFoundException("No extension found at the specified path", extension); | |
| } | |
| this.extensionFiles.Add(extension); | |
| } | |
| } | |
| /// <summary> | |
| /// Adds a base64-encoded string representing a Chrome extension to the list of extensions | |
| /// to be installed in the instance of Chrome. | |
| /// </summary> | |
| /// <param name="extension">A base64-encoded string representing the extension to add.</param> | |
| /// <exception cref="ArgumentException">If <paramref name="extension"/> is <see langword="null"/> or <see cref="string.Empty"/>.</exception> | |
| /// <exception cref="WebDriverException">If the extension string is not valid base-64.</exception> | |
| public void AddEncodedExtension(string extension) | |
| { | |
| if (string.IsNullOrEmpty(extension)) | |
| { | |
| throw new ArgumentException("extension must not be null or empty", nameof(extension)); | |
| } | |
| this.AddEncodedExtensions(extension); | |
| } | |
| /// <summary> | |
| /// Adds a list of base64-encoded strings representing Chrome extensions to the list of extensions | |
| /// to be installed in the instance of Chrome. | |
| /// </summary> | |
| /// <param name="extensions">An array of base64-encoded strings representing the extensions to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="extensions"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="WebDriverException">If an extension string is not valid base-64.</exception> | |
| public void AddEncodedExtensions(params string[] extensions) | |
| { | |
| this.AddEncodedExtensions((IEnumerable<string>)extensions); | |
| } | |
| /// <summary> | |
| /// Adds a list of base64-encoded strings representing Chrome extensions to be installed | |
| /// in the instance of Chrome. | |
| /// </summary> | |
| /// <param name="extensions">An <see cref="IEnumerable{T}"/> of base64-encoded strings | |
| /// representing the extensions to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="extensions"/> is <see langword="null"/>.</exception> | |
| /// <exception cref="WebDriverException">If an extension string is not valid base-64.</exception> | |
| public void AddEncodedExtensions(IEnumerable<string> extensions) | |
| { | |
| if (extensions == null) | |
| { | |
| throw new ArgumentNullException(nameof(extensions), "extensions must not be null"); | |
| } | |
| foreach (string extension in extensions) | |
| { | |
| // Run the extension through the base64 converter to test that the | |
| // string is not malformed. | |
| try | |
| { | |
| Convert.FromBase64String(extension); | |
| } | |
| catch (FormatException ex) | |
| { | |
| throw new WebDriverException("Could not properly decode the base64 string", ex); | |
| } | |
| this.encodedExtensions.Add(extension); | |
| } | |
| } | |
| /// <summary> | |
| /// Adds a preference for the user-specific profile or "user data directory." | |
| /// If the specified preference already exists, it will be overwritten. | |
| /// </summary> | |
| /// <param name="preferenceName">The name of the preference to set.</param> | |
| /// <param name="preferenceValue">The value of the preference to set.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="preferenceName"/> is <see langword="null"/>.</exception> | |
| public void AddUserProfilePreference(string preferenceName, object preferenceValue) | |
| { | |
| if (this.userProfilePreferences == null) | |
| { | |
| this.userProfilePreferences = new Dictionary<string, object>(); | |
| } | |
| this.userProfilePreferences[preferenceName] = preferenceValue; | |
| } | |
| /// <summary> | |
| /// Adds a preference for the local state file in the user's data directory for Chromium. | |
| /// If the specified preference already exists, it will be overwritten. | |
| /// </summary> | |
| /// <param name="preferenceName">The name of the preference to set.</param> | |
| /// <param name="preferenceValue">The value of the preference to set.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="preferenceName"/> is <see langword="null"/>.</exception> | |
| public void AddLocalStatePreference(string preferenceName, object preferenceValue) | |
| { | |
| if (this.localStatePreferences == null) | |
| { | |
| this.localStatePreferences = new Dictionary<string, object>(); | |
| } | |
| this.localStatePreferences[preferenceName] = preferenceValue; | |
| } | |
| /// <summary> | |
| /// Allows the Chromium browser to emulate a mobile device. | |
| /// </summary> | |
| /// <param name="deviceName">The name of the device to emulate. The device name must be a | |
| /// valid device name from the Chrome DevTools Emulation panel.</param> | |
| /// <remarks>Specifying an invalid device name will not throw an exception, but | |
| /// will generate an error in Chrome when the driver starts. To unset mobile | |
| /// emulation, call this method with <see langword="null"/> as the argument.</remarks> | |
| public void EnableMobileEmulation(string? deviceName) | |
| { | |
| this.mobileEmulationDeviceSettings = null; | |
| this.mobileEmulationDeviceName = deviceName; | |
| } | |
| /// <summary> | |
| /// Allows the Chromium browser to emulate a mobile device. | |
| /// </summary> | |
| /// <param name="deviceSettings">The <see cref="ChromiumMobileEmulationDeviceSettings"/> | |
| /// object containing the settings of the device to emulate.</param> | |
| /// <exception cref="ArgumentException">Thrown if the device settings option does | |
| /// not have a user agent string set.</exception> | |
| /// <remarks>Specifying an invalid device name will not throw an exception, but | |
| /// will generate an error in Chrome when the driver starts. To unset mobile | |
| /// emulation, call this method with <see langword="null"/> as the argument.</remarks> | |
| public void EnableMobileEmulation(ChromiumMobileEmulationDeviceSettings? deviceSettings) | |
| { | |
| this.mobileEmulationDeviceName = null; | |
| if (deviceSettings != null && string.IsNullOrEmpty(deviceSettings.UserAgent)) | |
| { | |
| throw new ArgumentException("Device settings must include a user agent string.", nameof(deviceSettings)); | |
| } | |
| this.mobileEmulationDeviceSettings = deviceSettings; | |
| } | |
| /// <summary> | |
| /// Adds a type of window that will be listed in the list of window handles | |
| /// returned by the Chrome driver. | |
| /// </summary> | |
| /// <param name="windowType">The name of the window type to add.</param> | |
| /// <remarks>This method can be used to allow the driver to access {webview} | |
| /// elements by adding "webview" as a window type.</remarks> | |
| /// <exception cref="ArgumentException">If <paramref name="windowType"/> is <see langword="null"/> or <see cref="string.Empty"/>.</exception> | |
| public void AddWindowType(string windowType) | |
| { | |
| if (string.IsNullOrEmpty(windowType)) | |
| { | |
| throw new ArgumentException("windowType must not be null or empty", nameof(windowType)); | |
| } | |
| this.AddWindowTypes(windowType); | |
| } | |
| /// <summary> | |
| /// Adds a list of window types that will be listed in the list of window handles | |
| /// returned by the Chromium driver. | |
| /// </summary> | |
| /// <param name="windowTypesToAdd">An array of window types to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="windowTypesToAdd"/> is <see langword="null"/>.</exception> | |
| public void AddWindowTypes(params string[] windowTypesToAdd) | |
| { | |
| this.AddWindowTypes((IEnumerable<string>)windowTypesToAdd); | |
| } | |
| /// <summary> | |
| /// Adds a list of window types that will be listed in the list of window handles | |
| /// returned by the Chromium driver. | |
| /// </summary> | |
| /// <param name="windowTypesToAdd">An <see cref="IEnumerable{T}"/> of window types to add.</param> | |
| /// <exception cref="ArgumentNullException">If <paramref name="windowTypesToAdd"/> is <see langword="null"/>.</exception> | |
| public void AddWindowTypes(IEnumerable<string> windowTypesToAdd) | |
| { | |
| if (windowTypesToAdd == null) | |
| { | |
| throw new ArgumentNullException(nameof(windowTypesToAdd), "windowTypesToAdd must not be null"); | |
| } | |
| this.windowTypes.AddRange(windowTypesToAdd); | |
| } | |
| /// <summary> | |
| /// Provides a means to add additional capabilities not yet added as type safe options | |
| /// for the Chromium driver. | |
| /// </summary> | |
| /// <param name="optionName">The name of the capability to add.</param> | |
| /// <param name="optionValue">The value of the capability to add.</param> | |
| /// <exception cref="ArgumentException"> | |
| /// thrown when attempting to add a capability for which there is already a type safe option, or | |
| /// when <paramref name="optionName"/> is <see langword="null"/> or the empty string. | |
| /// </exception> | |
| /// <remarks>Calling <see cref="AddAdditionalChromiumOption(string, object)"/> | |
| /// where <paramref name="optionName"/> has already been added will overwrite the | |
| /// existing value with the new value in <paramref name="optionValue"/>. | |
| /// Calling this method adds capabilities to the Chromium-specific options object passed to | |
| /// webdriver executable (e.g. property name 'goog:chromeOptions').</remarks> | |
| /// <exception cref="ArgumentException"> | |
| /// thrown when attempting to add a capability for which there is already a type safe option, or | |
| /// when <paramref name="optionName"/> is <see langword="null"/> or the empty string. | |
| /// </exception> | |
| protected void AddAdditionalChromiumOption(string optionName, object optionValue) | |
| { | |
| this.ValidateCapabilityName(optionName); | |
| this.additionalChromeOptions[optionName] = optionValue; | |
| } | |
| /// <summary> | |
| /// Returns DesiredCapabilities for Chromium with these options included as | |
| /// capabilities. This does not copy the options. Further changes will be | |
| /// reflected in the returned capabilities. | |
| /// </summary> | |
| /// <returns>The DesiredCapabilities for Chrome with these options.</returns> | |
| public override ICapabilities ToCapabilities() | |
| { | |
| Dictionary<string, object> chromeOptions = this.BuildChromeOptionsDictionary(); | |
| IWritableCapabilities capabilities = this.GenerateDesiredCapabilities(false); | |
| capabilities.SetCapability(this.CapabilityName, chromeOptions); | |
| AddVendorSpecificChromiumCapabilities(capabilities); | |
| Dictionary<string, object>? loggingPreferences = this.GenerateLoggingPreferencesDictionary(); | |
| if (loggingPreferences != null) | |
| { | |
| capabilities.SetCapability(LoggingPreferencesChromeOption, loggingPreferences); | |
| } | |
| return capabilities.AsReadOnly(); | |
| } | |
| /// <summary> | |
| /// Adds vendor-specific capabilities for Chromium-based browsers. | |
| /// </summary> | |
| /// <param name="capabilities">The capabilities to add.</param> | |
| protected virtual void AddVendorSpecificChromiumCapabilities(IWritableCapabilities capabilities) | |
| { | |
| } | |
| private Dictionary<string, object> BuildChromeOptionsDictionary() | |
| { | |
| Dictionary<string, object> chromeOptions = new Dictionary<string, object>(); | |
| if (this.Arguments.Count > 0) | |
| { | |
| chromeOptions[ArgumentsChromeOption] = this.Arguments; | |
| } | |
| if (!string.IsNullOrEmpty(this.BinaryLocation)) | |
| { | |
| chromeOptions[BinaryChromeOption] = this.BinaryLocation!; | |
| } | |
| ReadOnlyCollection<string> extensions = this.Extensions; | |
| if (extensions.Count > 0) | |
| { | |
| chromeOptions[ExtensionsChromeOption] = extensions; | |
| } | |
| if (this.localStatePreferences != null && this.localStatePreferences.Count > 0) | |
| { | |
| chromeOptions[LocalStateChromeOption] = this.localStatePreferences; | |
| } | |
| if (this.userProfilePreferences != null && this.userProfilePreferences.Count > 0) | |
| { | |
| chromeOptions[PreferencesChromeOption] = this.userProfilePreferences; | |
| } | |
| if (this.LeaveBrowserRunning) | |
| { | |
| chromeOptions[DetachChromeOption] = this.LeaveBrowserRunning; | |
| } | |
| if (!this.useSpecCompliantProtocol) | |
| { | |
| chromeOptions[UseSpecCompliantProtocolOption] = this.useSpecCompliantProtocol; | |
| } | |
| if (!string.IsNullOrEmpty(this.DebuggerAddress)) | |
| { | |
| chromeOptions[DebuggerAddressChromeOption] = this.DebuggerAddress!; | |
| } | |
| if (this.excludedSwitches.Count > 0) | |
| { | |
| chromeOptions[ExcludeSwitchesChromeOption] = this.excludedSwitches; | |
| } | |
| if (!string.IsNullOrEmpty(this.MinidumpPath)) | |
| { | |
| chromeOptions[MinidumpPathChromeOption] = this.MinidumpPath!; | |
| } | |
| if (!string.IsNullOrEmpty(this.mobileEmulationDeviceName) || this.mobileEmulationDeviceSettings != null) | |
| { | |
| chromeOptions[MobileEmulationChromeOption] = GenerateMobileEmulationSettingsDictionary(this.mobileEmulationDeviceSettings, this.mobileEmulationDeviceName); | |
| } | |
| if (this.PerformanceLoggingPreferences != null) | |
| { | |
| chromeOptions[PerformanceLoggingPreferencesChromeOption] = GeneratePerformanceLoggingPreferencesDictionary(this.PerformanceLoggingPreferences); | |
| } | |
| if (this.AndroidOptions != null) | |
| { | |
| AddAndroidOptions(chromeOptions, this.AndroidOptions); | |
| } | |
| if (this.windowTypes.Count > 0) | |
| { | |
| chromeOptions[WindowTypesChromeOption] = this.windowTypes; | |
| } | |
| foreach (KeyValuePair<string, object> pair in this.additionalChromeOptions) | |
| { | |
| chromeOptions.Add(pair.Key, pair.Value); | |
| } | |
| return chromeOptions; | |
| } | |
| private static void AddAndroidOptions(Dictionary<string, object> chromeOptions, ChromiumAndroidOptions androidOptions) | |
| { | |
| chromeOptions["androidPackage"] = androidOptions.AndroidPackage; | |
| if (!string.IsNullOrEmpty(androidOptions.AndroidDeviceSerial)) | |
| { | |
| chromeOptions["androidDeviceSerial"] = androidOptions.AndroidDeviceSerial!; | |
| } | |
| if (!string.IsNullOrEmpty(androidOptions.AndroidActivity)) | |
| { | |
| chromeOptions["androidActivity"] = androidOptions.AndroidActivity!; | |
| } | |
| if (!string.IsNullOrEmpty(androidOptions.AndroidProcess)) | |
| { | |
| chromeOptions["androidProcess"] = androidOptions.AndroidProcess!; | |
| } | |
| if (androidOptions.UseRunningApp) | |
| { | |
| chromeOptions["androidUseRunningApp"] = androidOptions.UseRunningApp; | |
| } | |
| } | |
| private static Dictionary<string, object> GeneratePerformanceLoggingPreferencesDictionary(ChromiumPerformanceLoggingPreferences prefs) | |
| { | |
| Dictionary<string, object> perfLoggingPrefsDictionary = new Dictionary<string, object>(); | |
| perfLoggingPrefsDictionary["enableNetwork"] = prefs.IsCollectingNetworkEvents; | |
| perfLoggingPrefsDictionary["enablePage"] = prefs.IsCollectingPageEvents; | |
| string tracingCategories = prefs.TracingCategories; | |
| if (!string.IsNullOrEmpty(tracingCategories)) | |
| { | |
| perfLoggingPrefsDictionary["traceCategories"] = tracingCategories; | |
| } | |
| perfLoggingPrefsDictionary["bufferUsageReportingInterval"] = Convert.ToInt64(prefs.BufferUsageReportingInterval.TotalMilliseconds); | |
| return perfLoggingPrefsDictionary; | |
| } | |
| private static Dictionary<string, object?> GenerateMobileEmulationSettingsDictionary(ChromiumMobileEmulationDeviceSettings? settings, string? deviceName) | |
| { | |
| Dictionary<string, object?> mobileEmulationSettings = new Dictionary<string, object?>(); | |
| if (!string.IsNullOrEmpty(deviceName)) | |
| { | |
| mobileEmulationSettings["deviceName"] = deviceName!; | |
| } | |
| else if (settings != null) | |
| { | |
| mobileEmulationSettings["userAgent"] = settings.UserAgent; | |
| Dictionary<string, object> deviceMetrics = new Dictionary<string, object>(); | |
| deviceMetrics["width"] = settings.Width; | |
| deviceMetrics["height"] = settings.Height; | |
| deviceMetrics["pixelRatio"] = settings.PixelRatio; | |
| if (!settings.EnableTouchEvents) | |
| { | |
| deviceMetrics["touch"] = settings.EnableTouchEvents; | |
| } | |
| mobileEmulationSettings["deviceMetrics"] = deviceMetrics; | |
| } | |
| return mobileEmulationSettings; | |
| } | |
| } |