// Copyright © 2010 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.
|
|
#pragma once
|
|
#include "Stdafx.h"
|
|
using namespace System::Collections::Generic;
|
using namespace System::IO;
|
|
namespace CefSharp
|
{
|
/// <summary>
|
/// Initialization settings. Many of these and other settings can also configured using command-line switches.
|
/// WPF/WinForms/OffScreen each have their own CefSettings implementation that sets
|
/// relevant settings e.g. OffScreen starts with audio muted.
|
/// </summary>
|
public ref class CefSettingsBase abstract
|
{
|
private:
|
/// <summary>
|
/// CEF V8 Extensions
|
/// </summary>
|
List<V8Extension^>^ _cefExtensions;
|
/// <summary>
|
/// Command Line Arguments Dictionary.
|
/// </summary>
|
CommandLineArgDictionary^ _cefCommandLineArgs;
|
|
internal:
|
/// <summary>
|
/// CefSettings unmanaged pointer
|
/// </summary>
|
::CefSettings* _cefSettings;
|
/// <summary>
|
/// CefCustomScheme collection
|
/// </summary>
|
List<CefCustomScheme^>^ _cefCustomSchemes;
|
|
public:
|
/// <summary>
|
/// Default Constructor.
|
/// </summary>
|
CefSettingsBase() : _cefSettings(new ::CefSettings())
|
{
|
_cefSettings->multi_threaded_message_loop = true;
|
_cefSettings->no_sandbox = true;
|
BrowserSubprocessPath = Path::Combine(Path::GetDirectoryName(CefSettingsBase::typeid->Assembly->Location), "CefSharp.BrowserSubprocess.exe");
|
_cefCustomSchemes = gcnew List<CefCustomScheme^>();
|
_cefExtensions = gcnew List<V8Extension^>();
|
_cefCommandLineArgs = gcnew CommandLineArgDictionary();
|
|
//Disable site isolation trials as this causes problems with frames
|
//being hosted in different render processes.
|
//https://github.com/cefsharp/CefSharp/issues/2967
|
_cefCommandLineArgs->Add("disable-site-isolation-trials");
|
}
|
|
/// <summary>
|
/// Finalizer.
|
/// </summary>
|
!CefSettingsBase()
|
{
|
delete _cefSettings;
|
}
|
|
/// <summary>
|
/// Destructor.
|
/// </summary>
|
~CefSettingsBase()
|
{
|
this->!CefSettingsBase();
|
}
|
|
/// <summary>
|
/// Add Customs schemes to this collection.
|
/// </summary>
|
property IEnumerable<CefCustomScheme^>^ CefCustomSchemes
|
{
|
IEnumerable<CefCustomScheme^>^ get() { return _cefCustomSchemes; }
|
}
|
|
/// <summary>
|
/// List of all V8Extensions to be registered using CefRegisterExtension in the render process.
|
/// </summary>
|
virtual property IEnumerable<V8Extension^>^ Extensions
|
{
|
IEnumerable<V8Extension^>^ get() { return _cefExtensions; }
|
}
|
|
/// <summary>
|
/// Add custom command line argumens to this collection, they will be added in OnBeforeCommandLineProcessing. The
|
/// CefSettings.CommandLineArgsDisabled value can be used to start with an empty command-line object. Any values specified in
|
/// CefSettings that equate to command-line arguments will be set before this method is called.
|
/// </summary>
|
virtual property CommandLineArgDictionary^ CefCommandLineArgs
|
{
|
CommandLineArgDictionary^ get() { return _cefCommandLineArgs; }
|
}
|
|
/// <summary>
|
/// Set to true to disable configuration of browser process features using standard CEF and Chromium command-line arguments.
|
/// Configuration can still be specified using CEF data structures or by adding to CefCommandLineArgs.
|
/// </summary>
|
property bool CommandLineArgsDisabled
|
{
|
bool get() { return _cefSettings->command_line_args_disabled == 1; }
|
void set(bool value) { _cefSettings->command_line_args_disabled = value; }
|
}
|
|
/// <summary>
|
/// Set to true to control browser process main (UI) thread message pump scheduling via the
|
/// IBrowserProcessHandler.OnScheduleMessagePumpWork callback. This option is recommended for use in combination with the
|
/// Cef.DoMessageLoopWork() function in cases where the CEF message loop must be integrated into an existing application message
|
/// loop (see additional comments and warnings on Cef.DoMessageLoopWork). Enabling this option is not recommended for most users;
|
/// leave this option disabled and use either MultiThreadedMessageLoop (the default) if possible.
|
/// </summary>
|
property bool ExternalMessagePump
|
{
|
bool get() { return _cefSettings->external_message_pump == 1; }
|
void set(bool value) { _cefSettings->external_message_pump = value; }
|
}
|
|
/// <summary>
|
/// Set to true to have the browser process message loop run in a separate thread. If false than the CefDoMessageLoopWork()
|
/// function must be called from your application message loop. This option is only supported on Windows. The default value is
|
/// true.
|
/// </summary>
|
property bool MultiThreadedMessageLoop
|
{
|
bool get() { return _cefSettings->multi_threaded_message_loop == 1; }
|
void set(bool value) { _cefSettings->multi_threaded_message_loop = value; }
|
}
|
|
/// <summary>
|
/// The path to a separate executable that will be launched for sub-processes. By default the browser process executable is used.
|
/// See the comments on Cef.ExecuteProcess() for details. If this value is non-empty then it must be an absolute path.
|
/// Also configurable using the "browser-subprocess-path" command-line switch.
|
/// Defaults to using the provided CefSharp.BrowserSubprocess.exe instance
|
/// </summary>
|
property String^ BrowserSubprocessPath
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->browser_subprocess_path); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->browser_subprocess_path, value); }
|
}
|
|
/// <summary>
|
/// The location where data for the global browser cache will be stored on disk. In this value is non-empty then it must be
|
/// an absolute path that is must be either equal to or a child directory of CefSettings.RootCachePath (if RootCachePath is
|
/// empty it will default to this value). If the value is empty then browsers will be created in "incognito mode" where
|
/// in-memory caches are used for storage and no data is persisted to disk. HTML5 databases such as localStorage will only
|
/// persist across sessions if a cache path is specified. Can be overridden for individual RequestContext instances via the
|
/// RequestContextSettings.CachePath value.
|
/// </summary>
|
property String^ CachePath
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->cache_path); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->cache_path, value); }
|
}
|
|
/// <summary>
|
/// The root directory that all CefSettings.CachePath and RequestContextSettings.CachePath values must have in common. If this
|
/// value is empty and CefSettings.CachePath is non-empty then it will default to the CefSettings.CachePath value.
|
/// If this value is non-empty then it must be an absolute path. Failure to set this value correctly may result in the sandbox
|
/// blocking read/write access to the CachePath directory. NOTE: CefSharp does not implement the CHROMIUM SANDBOX. A non-empty
|
/// RootCachePath can be used in conjuncation with an empty CefSettings.CachePath in instances where you would like browsers
|
/// attached to the Global RequestContext (the default) created in "incognito mode" and instances created with a custom
|
/// RequestContext using a disk based cache.
|
/// </summary>
|
property String^ RootCachePath
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->root_cache_path); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->root_cache_path, value); }
|
}
|
|
/// <summary>
|
/// The location where user data such as spell checking dictionary files will be stored on disk. If this value is empty then the
|
/// default user data directory will be used ("Local Settings\Application Data\CEF\User Data" directory under the user
|
/// profile directory on Windows). If this value is non-empty then it must be an absolute path.
|
/// </summary>
|
property String^ UserDataPath
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->user_data_path); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->user_data_path, value); }
|
}
|
|
/// <summary>
|
/// Set to true in order to completely ignore SSL certificate errors. This is NOT recommended.
|
/// </summary>
|
property bool IgnoreCertificateErrors
|
{
|
bool get() { return _cefSettings->ignore_certificate_errors == 1; }
|
void set(bool value) { _cefSettings->ignore_certificate_errors = value; }
|
}
|
|
/// <summary>
|
/// The locale string that will be passed to WebKit. If empty the default locale of "en-US" will be used. Also configurable using
|
/// the "lang" command-line switch.
|
/// </summary>
|
property String^ Locale
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->locale); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->locale, value); }
|
}
|
|
/// <summary>
|
/// The fully qualified path for the locales directory. If this value is empty the locales directory must be located in the
|
/// module directory. If this value is non-empty then it must be an absolute path. Also configurable using the "locales-dir-path"
|
/// command-line switch.
|
/// </summary>
|
property String^ LocalesDirPath
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->locales_dir_path); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->locales_dir_path, value); }
|
}
|
|
/// <summary>
|
/// The fully qualified path for the resources directory. If this value is empty the cef.pak and/or devtools_resources.pak files
|
/// must be located in the module directory. Also configurable using the "resources-dir-path" command-line switch.
|
/// </summary>
|
property String^ ResourcesDirPath
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->resources_dir_path); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->resources_dir_path, value); }
|
}
|
|
/// <summary>
|
/// The directory and file name to use for the debug log. If empty a default log file name and location will be used. On Windows
|
/// a "debug.log" file will be written in the main executable directory. Also configurable using the"log-file" command- line
|
/// switch.
|
/// </summary>
|
property String^ LogFile
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->log_file); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->log_file, value); }
|
}
|
|
/// <summary>
|
/// The log severity. Only messages of this severity level or higher will be logged. When set to
|
/// <see cref="CefSharp::LogSeverity::Disable"/> no messages will be written to the log file, but Fatal messages will still be
|
/// output to stderr. Also configurable using the "log-severity" command-line switch with a value of "verbose", "info", "warning",
|
/// "error", "fatal", "error-report" or "disable".
|
/// </summary>
|
property CefSharp::LogSeverity LogSeverity
|
{
|
CefSharp::LogSeverity get() { return (CefSharp::LogSeverity)_cefSettings->log_severity; }
|
void set(CefSharp::LogSeverity value) { _cefSettings->log_severity = (cef_log_severity_t)value; }
|
}
|
|
/// <summary>
|
/// Custom flags that will be used when initializing the V8 JavaScript engine. The consequences of using custom flags may not be
|
/// well tested. Also configurable using the "js-flags" command-line switch.
|
/// </summary>
|
property String^ JavascriptFlags
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->javascript_flags); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->javascript_flags, value); }
|
}
|
|
/// <summary>
|
/// Set to true to disable loading of pack files for resources and locales. A resource bundle handler must be provided for the
|
/// browser and render processes via CefApp::GetResourceBundleHandler() if loading of pack files is disabled. Also configurable
|
/// using the "disable-pack-loading" command- line switch.
|
/// </summary>
|
property bool PackLoadingDisabled
|
{
|
bool get() { return _cefSettings->pack_loading_disabled == 1; }
|
void set(bool value) { _cefSettings->pack_loading_disabled = value; }
|
}
|
|
/// <summary>
|
/// Value that will be inserted as the product portion of the default User-Agent string. If empty the Chromium product version
|
/// will be used. If UserAgent is specified this value will be ignored. Also configurable using the "product-version" command-
|
/// line switch.
|
/// </summary>
|
property String^ ProductVersion
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->product_version); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->product_version, value); }
|
}
|
|
/// <summary>
|
/// Set to a value between 1024 and 65535 to enable remote debugging on the specified port. For example, if 8080 is specified the
|
/// remote debugging URL will be http://localhost:8080. CEF can be remotely debugged from any CEF or Chrome browser window. Also
|
/// configurable using the "remote-debugging-port" command-line switch.
|
/// </summary>
|
property int RemoteDebuggingPort
|
{
|
int get() { return _cefSettings->remote_debugging_port; }
|
void set(int value) { _cefSettings->remote_debugging_port = value; }
|
}
|
|
/// <summary>
|
/// The number of stack trace frames to capture for uncaught exceptions. Specify a positive value to enable the
|
/// CefRenderProcessHandler:: OnUncaughtException() callback. Specify 0 (default value) and OnUncaughtException() will not be
|
/// called. Also configurable using the "uncaught-exception-stack-size" command-line switch.
|
/// </summary>
|
property int UncaughtExceptionStackSize
|
{
|
int get() { return _cefSettings->uncaught_exception_stack_size; }
|
void set(int value) { _cefSettings->uncaught_exception_stack_size = value; }
|
}
|
|
/// <summary>
|
/// Value that will be returned as the User-Agent HTTP header. If empty the default User-Agent string will be used. Also
|
/// configurable using the "user-agent" command-line switch.
|
/// </summary>
|
property String^ UserAgent
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->user_agent); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->user_agent, value); }
|
}
|
|
/// <summary>
|
/// Set to true (1) to enable windowless (off-screen) rendering support. Do not enable this value if the application does not use
|
/// windowless rendering as it may reduce rendering performance on some systems.
|
/// </summary>
|
property bool WindowlessRenderingEnabled
|
{
|
bool get() { return _cefSettings->windowless_rendering_enabled == 1; }
|
void set(bool value) { _cefSettings->windowless_rendering_enabled = value; }
|
}
|
|
/// <summary>
|
/// To persist session cookies (cookies without an expiry date or validity interval) by default when using the global cookie
|
/// manager set this value to true. Session cookies are generally intended to be transient and most Web browsers do not persist
|
/// them. A CachePath value must also be specified to enable this feature. Also configurable using the "persist-session-cookies"
|
/// command-line switch. Can be overridden for individual RequestContext instances via the
|
/// RequestContextSettings.PersistSessionCookies value.
|
/// </summary>
|
property bool PersistSessionCookies
|
{
|
bool get() { return _cefSettings->persist_session_cookies == 1; }
|
void set(bool value) { _cefSettings->persist_session_cookies = value; }
|
}
|
|
/// <summary>
|
/// To persist user preferences as a JSON file in the cache path directory set this value to true. A CachePath value must also be
|
/// specified to enable this feature. Also configurable using the "persist-user-preferences" command-line switch. Can be
|
/// overridden for individual RequestContext instances via the RequestContextSettings.PersistUserPreferences value.
|
/// </summary>
|
property bool PersistUserPreferences
|
{
|
bool get() { return _cefSettings->persist_user_preferences == 1; }
|
void set(bool value) { _cefSettings->persist_user_preferences = value; }
|
}
|
|
/// <summary>
|
/// Comma delimited ordered list of language codes without any whitespace that will be used in the "Accept-Language" HTTP header.
|
/// May be set globally using the CefSettings.AcceptLanguageList value. If both values are empty then "en-US,en" will be used.
|
///
|
/// </summary>
|
property String^ AcceptLanguageList
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->accept_language_list); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->accept_language_list, value); }
|
}
|
|
/// <summary>
|
/// Background color used for the browser before a document is loaded and when no document color is specified. The alpha
|
/// component must be either fully opaque (0xFF) or fully transparent (0x00). If the alpha component is fully opaque then the RGB
|
/// components will be used as the background color. If the alpha component is fully transparent for a WinForms browser then the
|
/// default value of opaque white be used. If the alpha component is fully transparent for a windowless (WPF/OffScreen) browser
|
/// then transparent painting will be enabled.
|
/// </summary>
|
virtual property uint32 BackgroundColor
|
{
|
uint32 get() { return _cefSettings->background_color; }
|
void set(uint32 value) { _cefSettings->background_color = value; }
|
}
|
|
/// <summary>
|
/// GUID string used for identifying the application. This is passed to the system AV function for scanning downloaded files. By
|
/// default, the GUID will be an empty string and the file will be treated as an untrusted file when the GUID is empty.
|
/// </summary>
|
property String^ ApplicationClientIdForFileScanning
|
{
|
String^ get() { return StringUtils::ToClr(_cefSettings->application_client_id_for_file_scanning); }
|
void set(String^ value) { StringUtils::AssignNativeFromClr(_cefSettings->application_client_id_for_file_scanning, value); }
|
}
|
|
/// <summary>
|
/// Registers a custom scheme using the provided settings.
|
/// </summary>
|
/// <param name="cefCustomScheme">The CefCustomScheme which provides the details about the scheme.</param>
|
void RegisterScheme(CefCustomScheme^ cefCustomScheme)
|
{
|
//Scheme names are converted to lowercase
|
cefCustomScheme->SchemeName = cefCustomScheme->SchemeName->ToLower();
|
|
_cefCustomSchemes->Add(cefCustomScheme);
|
}
|
|
/// <summary>
|
/// Register a new V8 extension with the specified JavaScript extension code.
|
/// </summary>
|
/// <exception cref="ArgumentException">Thrown when one or more arguments have unsupported or illegal values.</exception>
|
/// <param name="extension">The V8Extension that contains the extension code.</param>
|
void RegisterExtension(V8Extension^ extension)
|
{
|
if (_cefExtensions->Contains(extension))
|
{
|
throw gcnew ArgumentException("An extension with the same name is already registered.", "extension");
|
}
|
_cefExtensions->Add(extension);
|
}
|
|
/// <summary>
|
/// Set command line argument to disable GPU Acceleration. WebGL will use
|
/// software rendering via Swiftshader (https://swiftshader.googlesource.com/SwiftShader#introduction)
|
/// </summary>
|
void DisableGpuAcceleration()
|
{
|
if (!_cefCommandLineArgs->ContainsKey("disable-gpu"))
|
{
|
_cefCommandLineArgs->Add("disable-gpu");
|
}
|
}
|
|
/// <summary>
|
/// Set command line argument to enable Print Preview See
|
/// https://bitbucket.org/chromiumembedded/cef/issues/123/add-support-for-print-preview for details.
|
/// </summary>
|
void EnablePrintPreview()
|
{
|
if (!_cefCommandLineArgs->ContainsKey("enable-print-preview"))
|
{
|
_cefCommandLineArgs->Add("enable-print-preview");
|
}
|
}
|
|
/// <summary>
|
/// Set command line arguments for best OSR (Offscreen and WPF) Rendering performance Swiftshader will be used for WebGL, look at the source
|
/// to determine which flags best suite your requirements. See https://swiftshader.googlesource.com/SwiftShader#introduction for
|
/// details on Swiftshader
|
/// </summary>
|
void SetOffScreenRenderingBestPerformanceArgs()
|
{
|
// Use software rendering and compositing (disable GPU) for increased FPS
|
// and decreased CPU usage.
|
// See https://bitbucket.org/chromiumembedded/cef/issues/1257 for details.
|
if (!_cefCommandLineArgs->ContainsKey("disable-gpu"))
|
{
|
_cefCommandLineArgs->Add("disable-gpu");
|
}
|
|
if (!_cefCommandLineArgs->ContainsKey("disable-gpu-compositing"))
|
{
|
_cefCommandLineArgs->Add("disable-gpu-compositing");
|
}
|
|
// Synchronize the frame rate between all processes. This results in
|
// decreased CPU usage by avoiding the generation of extra frames that
|
// would otherwise be discarded. The frame rate can be set at browser
|
// creation time via CefBrowserSettings.windowless_frame_rate or changed
|
// dynamically using CefBrowserHost::SetWindowlessFrameRate. In cefclient
|
// it can be set via the command-line using `--off-screen-frame-rate=XX`.
|
// See https://bitbucket.org/chromiumembedded/cef/issues/1368 for details.
|
if (!_cefCommandLineArgs->ContainsKey("enable-begin-frame-scheduling"))
|
{
|
_cefCommandLineArgs->Add("enable-begin-frame-scheduling");
|
}
|
}
|
};
|
}
|
