All Identifiers

Decodes the base64 encoded string |data|. The returned value will be NULL if the decoding fails.

Retrieve the current system time in a TCefBaseTime type.

Clear all scheme handler factories registered with the global request context. Returns false (0) on error. This function may be called on any thread in the browser process. Using this function is equivalent to calling cef_request_context_t::cef_request_context_get_global_context()->clear_schem e_handler_factories().

Return the blue byte from a cef_color_t value.

Return the red byte from a cef_color_t value.

Crash reporting is configured using an INI-style config file named "crash_reporter.cfg". On Windows and Linux this file must be placed next to the main application executable. On macOS this file must be placed in the top-level app bundle Resources directory (e.g. "<appname>.app/Contents/Resources"). File contents are as follows:

<pre> # Comments start with a hash character and must be on their own line.

[Config] ProductName=<Value of the "prod" crash key; defaults to "cef"> ProductVersion=<Value of the "ver" crash key; defaults to the CEF version> AppName=<Windows only; App-specific folder name component for storing crash information; default to "CEF"> ExternalHandler=<Windows only; Name of the external handler exe to use instead of re-launching the main exe; default to empty> BrowserCrashForwardingEnabled=<macOS only; True if browser process crashes should be forwarded to the system crash reporter; default to false> ServerURL=<crash server URL; default to empty> RateLimitEnabled=<True if uploads should be rate limited; default to true> MaxUploadsPerDay=<Max uploads per 24 hours, used if rate limit is enabled; default to 5> MaxDatabaseSizeInMb=<Total crash report disk usage greater than this value will cause older reports to be deleted; default to 20> MaxDatabaseAgeInDays=<Crash reports older than this value will be deleted; default to 5>

[CrashKeys] my_key1=<small|medium|large> my_key2=<small|medium|large> </pre>

Config section:

If "ProductName" and/or "ProductVersion" are set then the specified values will be included in the crash dump metadata. On macOS if these values are set to NULL then they will be retrieved from the Info.plist file using the "CFBundleName" and "CFBundleShortVersionString" keys respectively.

If "AppName" is set on Windows then crash report information (metrics, database and dumps) will be stored locally on disk under the "C:\Users\[CurrentUser]\AppData\Local\[AppName]\User Data" folder. On other platforms the cef_settings_t.root_cache_path value will be used.

If "ExternalHandler" is set on Windows then the specified exe will be launched as the crashpad-handler instead of re-launching the main process exe. The value can be an absolute path or a path relative to the main exe directory. On Linux the cef_settings_t.browser_subprocess_path value will be used. On macOS the existing subprocess app bundle will be used.

If "BrowserCrashForwardingEnabled" is set to true (1) on macOS then browser process crashes will be forwarded to the system crash reporter. This results in the crash UI dialog being displayed to the user and crash reports being logged under "~/Library/Logs/DiagnosticReports". Forwarding of crash reports from non-browser processes and Debug builds is always disabled.

If "ServerURL" is set then crashes will be uploaded as a multi-part POST request to the specified URL. Otherwise, reports will only be stored locally on disk.

If "RateLimitEnabled" is set to true (1) then crash report uploads will be rate limited as follows: 1. If "MaxUploadsPerDay" is set to a positive value then at most the specified number of crashes will be uploaded in each 24 hour period. 2. If crash upload fails due to a network or server error then an incremental backoff delay up to a maximum of 24 hours will be applied for retries. 3. If a backoff delay is applied and "MaxUploadsPerDay" is > 1 then the "MaxUploadsPerDay" value will be reduced to 1 until the client is restarted. This helps to avoid an upload flood when the network or server error is resolved. Rate limiting is not supported on Linux.

If "MaxDatabaseSizeInMb" is set to a positive value then crash report storage on disk will be limited to that size in megabytes. For example, on Windows each dump is about 600KB so a "MaxDatabaseSizeInMb" value of 20 equates to about 34 crash reports stored on disk. Not supported on Linux.

If "MaxDatabaseAgeInDays" is set to a positive value then crash reports older than the specified age in days will be deleted. Not supported on Linux.

CrashKeys section:

A maximum of 26 crash keys of each size can be specified for use by the application. Crash key values will be truncated based on the specified size (small = 64 bytes, medium = 256 bytes, large = 1024 bytes). The value of crash keys can be set from any thread or process using the CefSetCrashKeyValue function. These key/value pairs will be sent to the crash server along with the crash dump file.

Creates a new directory. On Windows if |prefix| is provided the new directory name is in the format of "prefixyyyy". Returns true (1) on success and sets |newTempPath| to the full path of the directory that was created. The directory is only readable by the current user. Calling this function on the browser process UI or IO threads is not allowed.

Creates a URL from the specified |parts|, which must contain a non-NULL spec or a non-NULL host and path (at a minimum), but not both.

Deletes the given path whether it's a file or a directory. If |path| is a directory all contents will be deleted. If |recursive| is true (1) any sub- directories and their contents will also be deleted (equivalent to executing "rm -rf", so use with caution). On POSIX environments if |path| is a symbolic link then only the symlink will be deleted. Returns true (1) on successful deletion or if |path| does not exist. Calling this function on the browser process UI or IO threads is not allowed.

This is a convenience function for formatting a URL in a concise and human- friendly way to help users make security-related decisions (or in other circumstances when people need to distinguish sites, origins, or otherwise- simplified URLs from each other). Internationalized domain names (IDN) may be presented in Unicode if the conversion is considered safe. The returned value will (a) omit the path for standard schemes, excepting file and filesystem, and (b) omit the port if it is the default for the scheme. Do not use this for URLs which will be parsed or sent to other applications.

Returns a URI with a DATA scheme using |aString| as the URI's data.

Get the extensions associated with the given mime type. This should be passed in lower case. There could be multiple extensions for a given mime type, like "html,htm" for "text/html", or "txt,text,html,..." for "text/*". Any existing elements in the provided vector will not be erased.

Returns the mime type for the specified file extension or an NULL string if unknown.

Get the temporary directory provided by the system. WARNING: In general, you should use the temp directory variants below instead of this function. Those variants will ensure that the proper permissions are set so that other users on the system can't edit them while they're open (which could lead to security issues).

Return the high int32_t value from an int64_t value.

Return an int64_t value with the specified low and high int32_t component values.

Returns true (1) if the application text direction is right-to-left.

Loads the existing "Certificate Revocation Lists" file that is managed by Google Chrome. This file can generally be found in Chrome's User Data directory (e.g. "C:\Users\[User]\AppData\Local\Google\Chrome\User Data\" on Windows) and is updated periodically by Chrome's component updater service. Must be called in the browser process after the context has been initialized. See https://dev.chromium.org/Home/chromium-security/crlsets for background.

Post a task for delayed execution on the specified thread. Equivalent to using TCefTaskRunnerRef.GetForThread(threadId).PostDelayedTask(task, delay_ms).

Register a new V8 extension with the specified JavaScript extension code and handler. Functions implemented by the handler are prototyped using the keyword 'native'. The calling of a native function is restricted to the scope in which the prototype of the native function is defined. This function may only be called on the render process main thread.

Example JavaScript extension code: <pre> // create the 'example' global object if it doesn't already exist. if (!example) example = {}; // create the 'example.test' global object if it doesn't already exist. if (!example.test) example.test = {}; (function() { // Define the function 'example.test.myfunction'. example.test.myfunction = function() { // Call CefV8Handler::Execute() with the function name 'MyFunction' // and no arguments. native function MyFunction(); return MyFunction(); }; // Define the getter function for parameter 'example.test.myparam'. example.test.__defineGetter__('myparam', function() { // Call CefV8Handler::Execute() with the function name 'GetMyParam' // and no arguments. native function GetMyParam(); return GetMyParam(); }); // Define the setter function for parameter 'example.test.myparam'. example.test.__defineSetter__('myparam', function(b) { // Call CefV8Handler::Execute() with the function name 'SetMyParam' // and a single argument. native function SetMyParam(); if(b) SetMyParam(b); });

// Extension definitions can also contain normal JavaScript variables // and functions. var myint = 0; example.test.increment = function() { myint += 1; return myint; }; })(); </pre>

Example usage in the page: <pre> // Call the function. example.test.myfunction(); // Set the parameter. example.test.myparam = value; // Get the parameter. value = example.test.myparam; // Call another function. example.test.increment(); </pre>

Remove an entry from the cross-origin access whitelist. Returns false (0) if |source_origin| is invalid or the whitelist cannot be accessed.

Converts PCefString to ustring.

Retrieve the current system time in a TCefTime type.

Converts TCefTime to a double which is the number of seconds since epoch (Jan 1, 1970). Webkit uses this format to represent time. A value of 0 means "not initialized".

Converts cef_time_t to time_t. time_t is almost always an integral value holding the number of seconds (not counting leap seconds) since 00:00, Jan 1 1970 UTC, corresponding to POSIX time.

Escapes characters in |text| which are unsuitable for use as a query parameter value. Everything except alphanumerics and -_.!~*'() will be converted to "%XX". If |use_plus| is true (1) spaces will change to "+". The result is basically the same as encodeURIComponent in Javacript.

Writes the contents of |srcDir| into a zip archive at |destFile|. If |includeHiddenFiles| is true (1) files starting with "." will be included. Returns true (1) on success. Calling this function on the browser process UI or IO threads is not allowed.

Platform API hash.

/include/capi/cef_trace_capi.h

/include/capi/cef_browser_capi.h

********************************* ********** CAPI VIEWS *********** ********************************* /include/capi/views/cef_browser_view_capi.h

/include/capi/cef_command_line_capi.h

Commit hash.

Cookie priority values.

/include/capi/cef_crash_util.h

/include/capi/cef_file_util_capi.h

The browser crashed. Internal use only: resume pending downloads if possible.

The file was blocked due to local policy.

The partial file didn't match the expected hash.

There is not enough room on the drive.

An attempt to check the safety of the download failed due to unexpected reasons. See http://crbug.com/153212.

An attempt was made to seek past the end of a file in opening a file (as part of resuming a previously interrupted download).

The file contains a virus.

Generic network failure.

The server has gone down.

No interrupt reason.

Server certificate problem.

An unexpected cross-origin redirect happened.

Server access forbidden.

Server didn't authorize access to resource.

The user canceled the download.

/include/internal/cef_dump_without_crashing_internal.h

/include/capi/cef_path_util_capi.h

/ include/capi/cef_i18n_util_capi.h

/include/capi/cef_process_util_capi.h

Desktop audio capture permission.

Device audio capture permission.

No permission.

/include/capi/views/cef_menu_button_capi.h

Result codes for ICefMediaRouter.CreateRoute. Should be kept in sync with Chromium's media_router::mojom::RouteRequestResultCode type.

This value may be used with the mseconds_between_dumps parameter in GlobalCEFApp.DumpWithoutCrashing.

Used when the shared textures are disabled.

Permission types used with OnShowPermissionPrompt. Some types are platform-specific or only supported with Chrome style. Should be kept in sync with Chromium's permissions::RequestType type.

/include/capi/cef_preference_capi.h

/include/capi/cef_process_message_capi.h

Direct proxy type: Never use a proxy.

Pac_script proxy type: Use a .pac proxy script.

/include/capi/cef_request_context_capi.h

/include/capi/cef_parser_capi.h

/include/capi/cef_response_capi.h

The process is of an unknown type.

Last Chrome result code.

Chrome was downgraded since the last launch. Perform downgrade processing and relaunch.

The GPU process exited because initialization failed.

Process hung.

Failed to install an item from the webstore when the kInstallEphemeralAppFromWebstore command line flag was present. As this flag is no longer supported, this return code should never be returned.

The Lacros process exited because the post-login parameters received from Ash are either empty or invalid (Lacros-only).

Process was killed by user or system.

Machine level install exists.

Normal exit code.

Generic code used to communicate some simple outcome back to the process that launched us. This is used for experiments and the actual meaning depends on the experiment.

Generic code used to communicate some simple outcome back to the process that launched us. This is used for experiments and the actual meaning depends on the experiment.

An early startup command was executed and the browser must exit.

Chrome detected that there was a new version waiting to launch and renamed the files and launched the new version. This result code is never returned from the main process, but is instead used as a signal for early termination of browser. See `IsNormalResultCode` below.

A dummy value we should not use. See crbug.com/152285.

The profile was in use on another host.

Windows sandbox failed to forbid HCKU caching.

Windows sandbox could not lower the token.

Windows sandbox failed to flush registry handles.

Last Sandbox result code.

Windows sandbox could not set the mitigation policy.

Failed to make Chrome default browser (not used?).

The browser process exited because system resource are exhausted. The system state can't be recovered and will be unstable.

Delete profile as well during uninstall.

The user changed their mind.

If CEF_SCHEME_OPTION_CSP_BYPASSING is set the scheme can bypass Content- Security-Policy (CSP) checks. This value should not be set in most cases where CEF_SCHEME_OPTION_STANDARD is set.

If CEF_SCHEME_OPTION_FETCH_ENABLED is set the scheme can perform Fetch API requests.

No options.

If CEF_SCHEME_OPTION_STANDARD is set the scheme will be treated as a standard scheme. Standard schemes are subject to URL canonicalization and parsing rules as defined in the Common Internet Scheme Syntax RFC 1738 Section 3.1 available at http://www.ietf.org/rfc/rfc1738.txt

In particular, the syntax for standard scheme URLs must be of the form: <pre> [scheme]://[username]:[password]@[host]:[port]/[url-path] </pre> Standard scheme URLs must have a host component that is a fully qualified domain name as defined in Section 3.5 of RFC 1034 [13] and Section 2.1 of RFC 1123. These URLs will be canonicalized to "scheme://host/path" in the simplest case and "scheme://username:password@host:port/path" in the most explicit case. For example, "scheme:host/path" and "scheme:///host/path" will both be canonicalized to "scheme://host/path". The origin of a standard scheme URL is the combination of scheme, host and port (i.e., "scheme://host:port" in the most explicit case).

For non-standard scheme URLs only the "scheme:" component is parsed and canonicalized. The remainder of the URL will be passed to the handler as- is. For example, "scheme:///some%20text" will remain the same. Non-standard scheme URLs cannot be used as a target for form submission.

/include/capi/cef_server_capi.h

/include/capi/cef_shared_process_message_builder_capi.h

Show the window as hidden (no dock thumbnail). Only supported on MacOS..

Show the window as minimized.

/include/internal/cef_string_list.h

/include/capi/cef_task_manager_capi.h

/include/capi/cef_thread_capi.h

Used when the shared textures are enabled.

/include/internal/cef_time.h

/include/capi/cef_urlrequest_capi.h

/include/capi/cef_v8_capi.h

/include/capi/cef_values_capi.h

/include/capi/cef_waitable_event_capi.h

Converts TCefBaseTime to TCefTime.

This constant is defined by Chromium in chrome/app/main_dll_loader_win.cc It's used with SetProcessShutdownParameters to set a shutdown priority for the subprocesses. $280 is the default value for applications.

Supported context menu edit state bit flags. These constants match their equivalents in Chromium's ContextMenuDataEditFlags and should not be renumbered.

Supported context menu media state bit flags. These constants match their equivalents in Chromium's ContextMenuData::MediaFlags and should not be renumbered.

A subframe page is selected.

A media node is selected.

The top page is selected.

command_id constants declared in cef_command_ids.h and used by some callbacks in ICefCommandHandler cef_command_ids.h is generated in /include/cef_command_ids.h

Returns the absolute path version of aPath.

Simplifies a path by removing navigation elements such as "." and ".." to produce a direct, well-formed path.

Determines if aPath is a valid Universal Naming Convention (UNC) path, as opposed to a path based on a drive letter.

Converts a TDateTime value to TCefTime.

DOM event category flag.

DOM event category flag.

DOM event category flag.

DOM event category flag.

DOM event category flag.

DOM event category flag.

DOM event category flag.

DOM event category flag.

Retrieve the current system time in a double type.

"Verb" of a drag-and-drop operation as negotiated between the source and destination.

"Verb" of a drag-and-drop operation as negotiated between the source and destination.

"Verb" of a drag-and-drop operation as negotiated between the source and destination.

"Verb" of a drag-and-drop operation as negotiated between the source and destination.

Convert an editting command to string.

Permission to access a resource, other than the network, was denied.

Returned when attempting to bind an address that is already in use.

An error adding a certificate to the OS certificate database.

The SSL handshake failed because of a bad or missing client certificate.

The client chose to block the request.

The request was blocked by CORB or ORB.

The request failed because the response was delivered along with requirements which are not met ('X-Frame-Options' and 'Content-Security-Policy' ancestor checks and 'Cross-Origin-Resource-Policy' for instance).

Received a challenge after the transaction has read some data, and the credentials aren't available. There isn't a way to get them at that point.

The cache was unable to read a checksum record on an entry. This can be returned from attempts to read from the cache. It is an internal error, returned by the SimpleCache backend, but not by any URLRequest methods or members.

The disk cache is unable to doom this entry.

Internal error code for the HTTP cache. The cache lock timeout has fired.

The disk cache is unable to open this entry.

The operation is not supported for this entry.

Unable to read from the disk cache.

Certificate Transparency was required for this connection, but the server did not provide CT information that complied with the policy.

The server responded with a certificate whose common name did not match the host name. This could mean:

1. An attacker has redirected our traffic to their server and is presenting a certificate for which they know the private key.

2. The server is misconfigured and responding with the wrong cert.

3. The user is on a wireless network and is being redirected to the network's login page.

4. The OS has used a DNS search suffix and the server doesn't have a certificate for the abbreviated name in the address bar.

The certificate database changed in some way.

The value immediately past the last certificate error code.

The certificate is known to be used for interception by an entity other the device owner.

The host name specified in the certificate is not unique.

The server responded with a certificate has been revoked. We have the capability to ignore this error, but it is probably not the thing to do.

Revocation information for the security certificate for this site is not available. This could mean:

1. An attacker has compromised the private key in the certificate and is blocking our attempt to find out that the cert was revoked.

2. The certificate is unrevoked, but the revocation server is busy or unavailable.

The certificate verifier configuration changed in some way.

The server responded with a certificate that is signed using a weak signature algorithm.

Server request for client certificate did not contain any types we support.

A connection was closed (corresponding to a TCP FIN).

A connection attempt was refused.

A connection attempt timed out.

Initializing content decoding failed.

The request failed because the URLRequestContext is shutting down, or has been shut down.

Certificate Transparency: Received a signed tree head whose JSON parsing was OK but was missing some of the fields.

The compression dictionary cannot be loaded.

DNS resolver received a malformed response.

The hostname resolution of HTTPS record was expected to be resolved with alpn values of supported protocols, but did not.

Suffix search list rules prevent resolution of the given host name.

Failed to resolve the hostname of a DNS-over-HTTPS server.

DNS server requires TCP

DNS transaction timed out.

ECH was enabled, the server was unable to decrypt the encrypted ClientHello, and additionally did not present a certificate valid for the public name.

The server closed the connection without sending any data.

Detecting the encoding of the response failed.

The file already exists.

Not enough room left on the disk.

The file is too large.

The request was blocked because of no H/2 or QUIC session.

A request to create an SSL tunnel connection through the HTTPS proxy received a 302 (temporary redirect) response. The response body might include a description of why the request failed.

TODO(crbug.com/40093955): This is deprecated and should not be used by new code.

The server returned a non-2xx HTTP response code.

Note that this error is only used by certain APIs that interpret the HTTP response itself. URLRequest for instance just passes most non-2xx response back as success.

CA import failed due to some other error.

Import failed - certificate already exists in database. Note it's a little weird this is an error but reimporting a PKCS12 is ok (no-op). That's how Mozilla does it, though.

The HTTP response body is transferred with Chunked-Encoding, but the terminating zero-length chunk was never sent when the connection is closed.

The IP address space of the remote endpoint differed from the previous observed value during the same request. Any cache entry for the affected request should be invalidated.

There were not enough resources to complete the operation.

An argument to the function is incorrect.

Error in chunked transfer encoding.

The handle or file descriptor is invalid.

Attempting to load an URL resulted in a redirect to an invalid URL.

An error occurred while handling a signed exchange.

An error occurred while handling a Web Bundle source.

Key generation failed.

A mandatory proxy configuration could not be used. Currently this means that a mandatory PAC script could not be fetched, parsed or executed.

The environment was not set up correctly for authentication. For example, no KDC could be found or the principal is unknown.

The message was too large for the transport. (for example a UDP message which exceeds size threshold).

An error occurred when trying to do a name resolution (DNS).

The request was blocked because it originated from a frame that has disabled network access.

An operation could not be completed because all network IO is suspended.

The operation failed because of unimplemented functionality.

An attempt to import a client certificate failed, as the user's key database lacked a corresponding private key.

There are no supported proxies in the provided list.

Memory allocation failed.

The evaluation of the PAC script failed.

PKCS #12 import failed due to incorrect password.

PKCS #12 import failed due to invalid/corrupt file.

PKCS #12 import failed due to unsupported features.

Failure to export private key.

Proxy Auth Requested without a valid Client Socket Handle.

The certificate presented by the HTTPS Proxy was invalid.

HTTP_1_1_REQUIRED error code received on HTTP/2 session to proxy.

A GOAWAY frame has been received indicating that the request has not been processed and is therefore safe to retry on a different connection.

There is a QUIC protocol error.

The response was 416 (Requested range not satisfiable) and the server cannot satisfy the range requested.

The HTTP response contained multiple Content-Disposition headers.

The HTTP response contained multiple Location headers.

The HTTP headers were truncated by an EOF.

The socket is already connected.

Failed to set the socket's receive buffer size as requested, despite success return code from setsockopt.

Failed to set the socket's receive buffer size as requested.

Failed establishing a connection to the SOCKS proxy server for a target host.

Decoding or encoding of compressed HTTP/2 headers failed.

The peer sent an improperly sized HTTP/2 frame.

HTTP/2 server didn't respond to the PING message.

Received HTTP/2 RST_STREAM frame with NO_ERROR error code. This error should be handled internally by HTTP/2 code, and should not make it above the SpdyStream layer.

Received an HTTP/2 frame on a closed stream.

An SSL peer sent us a fatal bad_record_mac alert. This has been observed from servers with buggy DEFLATE support.

The server requested a client certificate for SSL client authentication.

There were no common signature algorithms between our client certificate private key and the server's preferences.

We were unable to sign the CertificateVerify data of an SSL client auth handshake with the client certificate's private key.

Possible causes for this include the user implicitly or explicitly denying access to the private key, the private key may not be valid for signing, the key may be relying on a cached handle which is no longer valid, or the CSP won't allow arbitrary data to be signed.

An SSL peer sent us a fatal decrypt_error alert. This typically occurs when a peer could not correctly verify a signature (in CertificateVerify or ServerKeyExchange) or validate a Finished message.

The server's certificate has a keyUsage extension incompatible with the negotiated TLS key exchange method.

The SSL server required an unsupported cipher suite that has since been removed. This error will temporarily be signaled on a fallback for one or two releases immediately following a cipher suite's removal, after which the fallback will be removed.

An SSL protocol error occurred.

The SSL server presented a certificate which could not be decoded. This is not a certificate error code as no X509Certificate object is available. This error is fatal.

The SSL server sent us a fatal unrecognized_name alert.

FLIP data received without receiving a SYN_REPLY on the stream.

An operation timed out.

The ACCEPT_CH restart has been triggered too many times

An HTTP transaction was retried too many times due for authentication or invalid certificates. This may be due to a bug in the net stack that would otherwise infinite loop, or if the server or proxy continually requests fresh credentials or presents a fresh invalid certificate.

When handling a Trust Tokens protocol operation-executing request, the system was able to execute the request's Trust Tokens operation without sending the request to its destination: for instance, the results could have been present in a local cache (for redemption) or the operation could have been diverted to a local provider (for "platform-provided" issuance).

The attempt to reuse a connection to send proxy auth credentials failed before the AuthController was used to generate credentials. The caller should reuse the controller with a new connection. This error is only used internally by the network stack.

An unexpected error. This may be caused by a programming mistake or an invalid assumption.

The response was 407 (Proxy Authentication Required), yet we did not send the request to a proxy.

The scheme of the URL is unknown.

Attempting to load an URL with an unsafe port number. These are port numbers that correspond to services, which are not robust to spurious input that may be constructed as a result of an allowed web construct (e.g., HTTP looks a lot like SMTP, so form submission to port 25 is denied).

An HTTP Authentication scheme was tried which is not supported on this machine.

The upload failed because the upload stream needed to be re-read, due to a retry or a redirect, but the upload stream doesn't support that operation.

TLS 1.3 early data was offered, but the server responded with TLS 1.2 or earlier. This is an internal error code to account for a backwards-compatibility issue with early data and TLS 1.2. It will be received before any data is returned from the socket. The request should be retried with early data disabled.

See https://tools.ietf.org/html/rfc8446#appendix-D.3 for details.

There are too many pending WebSocketJob instances, so the new job was not pushed to the queue.

Content decoding failed due to the zstd window size being too big (over 8MB).

Supported event bit flag.

Supported event bit flag.

Supported event bit flag.

Supported event bit flag.

Supported event bit flag.

Supported event bit flag.

Supported event bit flag.

Like Open, but selects a folder to open.

Allows picking a nonexistent file, and prompts to overwrite if the file already exists.

Returns a command line switch value if it exists.

Retrieves the fully qualified path for the current module.

Returns the time interval between now and from_ in milliseconds. This funcion should only be used by TCEFTimerWorkScheduler.

Custom interface used to handle all the TCefApplicationCore events.

Implement this interface to provide handler implementations. Methods will be called by the process and/or thread indicated.

Callback interface used for asynchronous continuation of authentication requests.

Callback interface used to asynchronously continue a download.

A Layout manager that arranges child views vertically or horizontally in a side-by-side fashion with spacing around and between the child views. The child views are always sized according to their preferred size. If the host's bounds provide insufficient space, child views will be clamped. Excess space will not be distributed. Methods must be called on the browser process UI thread unless otherwise indicated.

Interface used to represent the browser process aspects of a browser. The functions of this interface can only be called in the browser process. They may be called on any thread in that process unless otherwise indicated in the comments.

A View hosting a ICefBrowser instance. Methods must be called on the browser process UI thread unless otherwise indicated.

Custom interface used to handle all the ICefBrowserViewDelegate events.

Implement this interface to handle Button events. The functions of this interface will be called on the browser process UI thread unless otherwise indicated.

Generic callback interface used for asynchronous continuation.

Implement this interface to handle events related to commands. The functions of this interface will be called on the UI thread.

Generic callback interface used for asynchronous completion.

Provides information about the context menu state. The functions of this interface can only be accessed on browser process the UI thread.

Interface used for managing cookies. The functions of this interface may be called on any thread unless otherwise indicated.

Interface used to read data from a stream. The functions of this interface may be called on any thread.

Callback interface for ICefBrowserHost.AddDevToolsMessageObserver. The functions of this interface will be called on the browser process UI thread.

Interface representing a dictionary value. Can be used on any process and thread.

Implement this interface to handle events related to browser display state. The functions of this interface will be called on the UI thread.

Interface used to represent a DOM node. The functions of this interface should only be called on the render process main thread.

Interface used to handle file downloads. The functions of this interface will called on the browser process UI thread.

Interface used to represent a download item.

Interface used to represent drag data. The functions of this interface may be called on any thread.

Implement this interface to receive notification when tracing has completed. The functions of this interface will be called on the browser process UI thread.

A simple Layout that causes the associated Panel's one child to be sized to match the bounds of its parent. Methods must be called on the browser process UI thread unless otherwise indicated.

Implement this interface to handle events related to focus. The functions of this interface will be called on the UI thread.

Implement this interface to handle events related to ICefFrame life span. The order of callbacks is:

(1) During initial ICefBrowserHost creation and navigation of the main frame: - ICefFrameHandler.OnFrameCreated => The initial main frame object has been created. Any commands will be queued until the frame is attached. - ICefFrameHandler.OnMainFrameChanged => The initial main frame object has been assigned to the browser. - ICefLifeSpanHandler.OnAfterCreated => The browser is now valid and can be used. - ICefFrameHandler.OnFrameAttached => The initial main frame object is now connected to its peer in the renderer process. Commands can be routed.

(2) During further ICefBrowserHost navigation/loading of the main frame and/or sub-frames: - ICefFrameHandler.OnFrameCreated => A new main frame or sub-frame object has been created. Any commands will be queued until the frame is attached. - ICefFrameHandler.OnFrameAttached => A new main frame or sub-frame object is now connected to its peer in the renderer process. Commands can be routed. - ICefFrameHandler.OnFrameDetached => An existing main frame or sub- frame object has lost its connection to the renderer process. If multiple objects are detached at the same time then notifications will be sent for any sub-frame objects before the main frame object. Commands can no longer be routed and will be discarded. - ICefFrameHandler.OnMainFrameChanged => A new main frame object has been assigned to the browser. This will only occur with cross-origin navigation or re-navigation after renderer process termination (due to crashes, etc).

(3) During final ICefBrowserHost destruction of the main frame: - ICefFrameHandler.OnFrameDetached => Any sub-frame objects have lost their connection to the renderer process. Commands can no longer be routed and will be discarded. - ICefLifeSpanHandler.OnBeforeClose => The browser has been destroyed. - ICefFrameHandler.OnFrameDetached => The main frame object have lost its connection to the renderer process. Notifications will be sent for any sub-frame objects before the main frame object. Commands can no longer be routed and will be discarded. - ICefFrameHandler.OnMainFrameChanged => The final main frame object has been removed from the browser.

Cross-origin navigation and/or loading receives special handling.

When the main frame navigates to a different origin the OnMainFrameChanged callback (2) will be executed with the old and new main frame objects.

When a new sub-frame is loaded in, or an existing sub-frame is navigated to, a different origin from the parent frame, a temporary sub-frame object will first be created in the parent's renderer process. That temporary sub-frame will then be discarded after the real cross-origin sub-frame is created in the new/target renderer process. The client will receive cross-origin navigation callbacks (2) for the transition from the temporary sub-frame to the real sub-frame. The temporary sub-frame will not recieve or execute commands during this transitional period (any sent commands will be discarded).

When a new popup browser is created in a different origin from the parent browser, a temporary main frame object for the popup will first be created in the parent's renderer process. That temporary main frame will then be discarded after the real cross-origin main frame is created in the new/target renderer process. The client will recieve creation and initial navigation callbacks (1) for the temporary main frame, followed by cross- origin navigation callbacks (2) for the transition from the temporary main frame to the real main frame. The temporary main frame may receive and execute commands during this transitional period (any sent commands may be executed, but the behavior is potentially undesirable since they execute in the parent browser's renderer process and not the new/target renderer process).

Callbacks will not be executed for placeholders that may be created during pre-commit navigation for sub-frames that do not yet exist in the renderer process. Placeholders will have ICefFrame.GetIdentifier() == -4.

The functions of this interface will be called on the UI thread unless otherwise indicated.

Callback interface used for asynchronous continuation of JavaScript dialog requests.

Implement this interface to handle events related to keyboard input. The functions of this interface will be called on the UI thread.

A Layout handles the sizing of the children of a Panel according to implementation-specific heuristics. Methods must be called on the browser process UI thread unless otherwise indicated.

Interface representing a list value. Can be used on any process and thread.

Callback interface used for asynchronous continuation of media access permission requests.

Implemented by the client to observe MediaRouter events and registered via ICefMediaRouter.AddObserver. The functions of this interface will be called on the browser process UI thread.

Callback interface for ICefMediaRouter.CreateRoute. The functions of this interface will be called on the browser process UI thread.

Represents a sink to which media can be routed. Instances of this object are retrieved via ICefMediaObserver.OnSinks. The functions of this interface may be called on any browser process thread unless otherwise indicated.

Represents a source from which media can be routed. Instances of this object are retrieved via ICefMediaRouter.GetSource. The functions of this interface may be called on any browser process thread unless otherwise indicated.

Implement this interface to handle MenuButton events. The functions of this interface will be called on the browser process UI thread unless otherwise indicated.

MenuButton pressed lock is released when this object is destroyed.

Implement this interface to handle menu model events. The functions of this interface will be called on the browser process UI thread unless otherwise indicated.

Callback interface for ICefBrowserHost.GetNavigationEntries. The functions of this interface will be called on the browser process UI thread.

A Panel is a container in the views hierarchy that can contain other Views as children. Methods must be called on the browser process UI thread unless otherwise indicated.

Custom interface used to handle all the ICefPanelDelegate events.

Implement this interface to handle events related to permission requests. The functions of this interface will be called on the browser process UI thread.

Interface used to represent post data for a web request. The functions of this interface may be called on any thread.

Manage access to preferences. Many built-in preferences are registered by Chromium. Custom preferences can be registered in ICefBrowserProcessHandler.OnRegisterCustomPreferences.

Implement this interface to handle printing on Linux. Each browser will have only one print job in progress at a time. The functions of this interface will be called on the browser process UI thread.

Interface representing print settings.

Structure the client can implement to provide a custom stream reader. The functions of this structure may be called on any thread.

Implement this interface to handle events when window rendering is disabled. The functions of this interface will be called on the UI thread.

Interface used to represent a web request. The functions of this interface may be called on any thread.

Implement this interface to provide handler implementations. The handler instance will not be released until all objects related to the context have been destroyed.

Callback interface for ICefRequestContext.ResolveHost.

Interface used to implement a custom resource bundle interface. See TCefSettings for additional options related to resource bundle loading. The functions of this interface may be called on multiple threads.

Callback for asynchronous continuation of ICefResourceHandler.read.

Callback for asynchronous continuation of ICefResourceHandler.skip.

Implement this interface to filter resource response content. The functions of this interface will be called on the browser process IO thread.

Callback interface for ICefBrowserHost.RunFileDialog. The functions of this interface will be called on the browser process UI thread.

Interface that creates ICefResourceHandler instances for handling scheme requests. The functions of this interface will always be called on the IO thread.

Callback interface used to select a client certificate for authentication.

Implement this interface to handle HTTP server requests. A new thread will be created for each ICefServer.CreateServer call (the "dedicated server thread"), and the functions of this interface will be called on that thread. It is therefore recommended to use a different ICefServerHandler instance for each ICefServer.CreateServer call to avoid thread safety issues in the ICefServerHandler implementation.

Interface that wraps platform-dependent share memory region mapping.

Interface representing SSL information.

Interface used to read data from a stream. The functions of this interface may be called on any thread.

Custom interface used to handle all the CEF functions related to CefStringList.

Custom interface used to handle all the CEF functions related to CefStringMultimap.

Implement this interface for asynchronous task execution. If the task is posted successfully and if the associated message loop is still running then the execute() function will be called on the target thread. If the task fails to post then the task object may be destroyed on the source thread instead of the target thread. For this reason be cautious when performing work in the task object destructor.

Interface that asynchronously executes tasks on the associated thread. It is safe to call the functions of this interface on any thread.

CEF maintains multiple internal threads that are used for handling different types of tasks in different processes. The TCefThreadId definitions in cef_types.h list the common CEF threads. Task runners are also available for other CEF threads as appropriate (for example, V8 WebWorker threads).

Implement this interface to handle Textfield events. The functions of this interface will be called on the browser process UI thread unless otherwise indicated.

A simple thread abstraction that establishes a message loop on a new thread. The consumer uses ICefTaskRunner to execute code on the thread's message loop. The thread is terminated when the ICefThread object is destroyed or stop() is called. All pending tasks queued on the thread's message loop will run to completion before the thread is terminated. cef_thread_create() can be called on any valid CEF thread in either the browser or render process. This interface should only be used for tasks that require a dedicated thread. In most cases you can post tasks to an existing CEF thread instead of creating a new one; see cef_task.h for details.

Interface used to make a URL request. URL requests are not associated with a browser instance so no ICefClient callbacks will be executed. URL requests can be created on any valid CEF thread in either the browser or render process. Once created the functions of the URL request object must be accessed on the same thread that created it.

Custom interface used to handle all the TCEFUrlRequestClientComponent events.

Callback interface that is passed to ICefV8value.CreateArrayBuffer.

Interface representing a V8 exception. The functions of this interface may be called on any render process thread.

Interface that should be implemented to handle V8 interceptor calls. The functions of this interface will be called on the thread associated with the V8 interceptor. Interceptor's named property handlers (with first argument of type CefString) are called when object is indexed by string. Indexed property handlers (with first argument of type int) are called when object is indexed by integer.

Interface representing a V8 stack trace handle. V8 handles can only be accessed from the thread on which they are created. Valid threads for creating a V8 handle include the render process main thread (TID_RENDERER) and WebWorker threads. A task runner for posting tasks on the associated thread can be retrieved via the ICefv8context.GetTaskRunner() function.

Interface that wraps other data value types. Complex types (binary, dictionary and list) will be referenced but not owned by this object. Can be used on any process and thread.

Implement this interface to handle view events. All size and position values are in density independent pixels (DIP) unless otherwise indicated. The functions of this interface will be called on the browser process UI thread unless otherwise indicated.

WaitableEvent is a thread synchronization tool that allows one thread to wait for another thread to finish some work. This is equivalent to using a Lock+ConditionVariable to protect a simple boolean value. However, using WaitableEvent in conjunction with a Lock to wait for a more complex state change (e.g., for an item to be added to a queue) is not recommended. In that case consider using a ConditionVariable instead of a WaitableEvent. It is safe to create and/or signal a WaitableEvent from any thread. Blocking on a WaitableEvent by calling the *wait() functions is not allowed on the browser process UI or IO threads.

Implement this interface to handle window events. The functions of this interface will be called on the browser process UI thread unless otherwise indicated.

Interface the client can implement to provide a custom stream writer. The functions of this interface may be called on any thread.

Interface representing the issuer or subject field of an X.509 certificate.

Interface that supports the reading of zip archives via the zlib unzip API. The functions of this interface should only be called on the thread that creates the object.