This creates a base class for a thing to help you implement the function pointers.
Image format used by the ICoreWebView2::CapturePreview method.
The type of key event that triggered an AcceleratorKeyPressed event.
Reason for moving focus.
The type of a permission request.
Response to a permission request.
Kind of process failure used in the ICoreWebView2ProcessFailedEventHandler interface.
Kind of JavaScript dialog used in the ICoreWebView2ScriptDialogOpeningEventHandler interface.
Error status values for web navigations.
Enum for web resource request contexts.
Describes how to interpret the alpha component of a pixel.
Specifies the button display state.
Enumerates the various representations of the ordering of audio channels. Must be kept synchronized with media::ChannelLayout from Chromium. See media\base\channel_layout.h
Supported Chrome toolbar types.
Print job color mode values.
Describes how to interpret the components of a pixel.
Windows COM initialization mode. Specifies how COM will be initialized for a new thread.
Composition underline style.
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.
Supported context menu media types. These constants match their equivalents in Chromium's ContextMenuDataMediaType and should not be renumbered.
Supported context menu type flags.
Cookie priority values.
Cookie same site values.
Specifies where along the cross axis the CefBoxLayout child views should be laid out.
Cursor type values.
Docking modes supported by CefWindow::AddOverlay.
DOM document types.
DOM event category flags.
DOM event processing phases.
DOM node types.
Print job duplex mode values.
Supported error code values. For the complete list of error values see "include/base/internal/cef_net_error_list.h".
Supported event bit flags.
Supported file dialog modes.
Focus sources.
Specifies the horizontal text alignment mode.
Supported JavaScript dialog types.
Options that can be passed to CefParseJSON.
Options that can be passed to CefWriteJSON.
Key event types.
Log severity levels.
Specifies where along the main axis the CefBoxLayout child views should be laid out.
Media access permissions used by OnRequestMediaAccessPermission.
Connection state for a MediaRoute object.
Result codes for CefMediaRouter::CreateRoute. Should be kept in sync with Chromium's media_router::mojom::RouteRequestResultCode type.
Icon types for a MediaSink object. Should be kept in sync with Chromium's
Specifies how a menu will be anchored for non-RTL languages. The opposite position will be used for RTL languages.
Supported color types for menu items.
Supported menu IDs. Non-English translations can be provided for the IDS_MENU_* strings in CefResourceBundleHandler::GetLocalizedString().
Supported menu item types.
Message loop types. Indicates the set of asynchronous events that a message loop can process.
Mouse button types.
Navigation types.
Paint element types.
Path key values.
Margin type for PDF printing.
Permission request results.
Permission types used with OnShowPermissionPrompt. Some types are platform-specific or only supported with the Chrome runtime. Should be kept in sync with Chromium's permissions::RequestType type.
The device type that caused the event.
Existing process IDs.
Supported quick menu state bit flags.
Policy for how the Referrer HTTP header value will be sent during navigation. If the --no-referrers command-line flag is specified then the policy value will be ignored and the Referrer value will never be sent. Must be kept synchronized with net::URLRequest::ReferrerPolicy from Chromium.
Return values for CefResponseFilter::Filter().
Return value types.
Supported UI scale factors for the platform. SCALE_FACTOR_NONE is used for density independent resources such as string, html/js files or an image that can be used for any scale factors (such as wallpapers).
Configuration options for registering a custom scheme. These values are used when calling AddCustomScheme.
Show states supported by CefWindowDelegate::GetInitialShowState.
Supported SSL content status flags. See content/public/common/ssl_status.h for more information.
Supported SSL version values. See net/ssl/ssl_connection_status_flags.h for more information.
Represents the state of a setting.
Storage types.
Process termination status values.
Certificate types supported by CefTestServer::CreateAndStart. The matching certificate file must exist in the "net/data/ssl/certificates" directory. See CefSetDataDirectoryForTests() for related configuration.
Represents commands available to TextField.
Text style types. Should be kepy in sync with gfx::TextStyle.
Existing thread IDs.
Thread priority values listed in increasing order of importance.
Touch points states types.
Values indicating what state of the touch handle is set.
URI unescape rules passed to CefURIDecode().
Flags used to customize the behavior of CefURLRequest.
Flags that represent CefURLRequest status.
Supported value types.
Supported XML encoding types. The parser supports ASCII, ISO-8859-1, and UTF16 (LE and BE) by default. All other types must be translated to UTF8 before being passed to the parser. If a BOM is detected and the correct decoder is available then that decoder will be used automatically.
XML node types.
This method is for anyone want to compare version correctly to determine which version is newer, older or same. It can be used to determine whether to use webview2 or certain feature base on version. Sets the value of result to -1, 0 or 1 if version1 is less than, equal or greater than version2 respectively. Returns E_INVALIDARG if it fails to parse any of the version strings or any input parameter is null. Input can directly use the versionInfo obtained from GetAvailableCoreWebView2BrowserVersionString, channel info will be ignored.
Creates an evergreen WebView2 Environment using the installed Edge version. This is equivalent to calling CreateCoreWebView2EnvironmentWithOptions with nullptr for browserExecutableFolder, userDataFolder, additionalBrowserArguments. See CreateCoreWebView2EnvironmentWithOptions for more details.
DLL export to create a WebView2 environment with a custom version of Edge, user data directory and/or additional options.
Get the browser version info including channel name if it is not the stable channel or the Embedded Edge. Channel names are beta, dev, and canary. If an override exists for the browserExecutableFolder or the channel preference, the override will be used. If there isn't an override, then the parameter passed to GetAvailableCoreWebView2BrowserVersionString is used.
Add an entry to the cross-origin access whitelist.
Decodes the base64 encoded string |data|. The returned value will be NULL if the decoding fails.
Encodes |data| as a base64 string.
Start tracing events on all processes. Tracing is initialized asynchronously and |callback| will be executed on the UI thread after initialization is complete.
Creates a new object that is not owned by any other object. The specified |data| will be copied.
Create a new browser using the window parameters specified by |windowInfo|. All values will be copied internally and the actual window (if any) will be created on the UI thread. If |request_context| is NULL the global request context will be used. This function can be called on any browser process thread and will not block. The optional |extra_info| parameter provides an opportunity to specify extra information specific to the created browser that will be passed to cef_render_process_handler_t::on_browser_created() in the render process.
Create a new browser using the window parameters specified by |windowInfo|. If |request_context| is NULL the global request context will be used. This function can only be called on the browser process UI thread. The optional |extra_info| parameter provides an opportunity to specify extra information specific to the created browser that will be passed to
Remove all entries from the cross-origin access whitelist. Returns false (0) if the whitelist cannot be accessed.
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
Create a new cef_command_line_t instance.
Returns the singleton global cef_command_line_t object. The returned object will be read-only.
Returns the global cookie manager. By default data will be stored at cef_settings_t.cache_path if specified or in memory otherwise. If |callback| is non-NULL it will be executed asnychronously on the UI thread after the manager's storage has been initialized. Using this function is equivalent to calling cef_request_context_t::cef_request_context_get_global_context()->Get DefaultCookieManager().
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:
Creates a new context object that shares storage with |other| and uses an optional |handler|.
Creates a directory and all parent directories if they don't already exist. Returns true (1) on successful creation or if the directory already exists. 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 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 |new_temp_path| 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 directory within another directory. Extra characters will be appended to |prefix| to ensure that the new directory does not have the same name as an existing directory. Returns true (1) on success and sets |new_dir| 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. Returns false (0) if |parts| isn't initialized as described.
Returns true (1) if called on the specified thread. Equivalent to using
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.
Creates a new object that is not owned by any other object.
Returns true (1) if the given path exists and is a directory. Calling this function on the browser process UI or IO threads is not allowed.
Perform a single iteration of CEF message loop processing. This function is provided for cases where the CEF message loop must be integrated into an existing application message loop. Use of this function is not recommended for most users; use either the cef_run_message_loop() function or cef_settings_t.multi_threaded_message_loop if possible. When using this function care must be taken to balance performance against excessive CPU usage. It is recommended to enable the cef_settings_t.external_message_pump option when using this function so that
Create a new cef_drag_data_t object.
Call during process startup to enable High-DPI support on Windows 7 or newer. Older versions of Windows should be left DPI-unaware because they do not support DirectWrite and GDI fonts are kerned very badly.
Stop tracing events on all processes.
This function should be called from the application entry point function to execute a secondary process. It can be used to run secondary processes from the browser client executable (default behavior) or from a separate executable specified by the cef_settings_t.browser_subprocess_path value. If called for the browser process (identified by no "type" command-line value) it will return immediately with a value of -1. If called for a recognized secondary process it will block until the process should exit and then return the process exit code. The |application| parameter may be NULL. The |windows_sandbox_info| parameter is only used on Windows and may be NULL (see cef_sandbox_win.h for details).
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.
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.
Retrieve the path associated with the specified |key|. Returns true (1) on success. Can be called on any thread in the browser process.
Get the temporary directory provided by the system.
Create a new cef_image_t. It will initially be NULL. Use the Add*() functions to add representations at different scale factors.
This function should be called on the main application thread to initialize the CEF browser process. The |application| parameter may be NULL. A return value of true (1) indicates that it succeeded and false (0) indicates that it failed. The |windows_sandbox_info| parameter is only used on Windows and may be NULL (see cef_sandbox_win.h for details).
Returns true (1) if the certificate status represents an error.
Returns true (1) if the application text direction is right-to-left.
Launches the process specified via |command_line|. Returns true (1) upon success. Must be called on the browser process TID_PROCESS_LAUNCHER thread.
Creates a new object that is not owned by any other object.
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.
Returns the MediaRouter object associated with the global request context. If |callback| is non-NULL it will be executed asnychronously on the UI thread after the manager's storage has been initialized. Equivalent to calling cef_request_context_t::cef_request_context_get_global_context()->get _media_router().
Create a new MenuModel with the specified |delegate|.
Returns the current system trace time or, if none is defined, the current high-res time. Can be used by clients to synchronize with the time information in trace events.
Parses the specified |json_string| and returns a dictionary or list representation. If JSON parsing fails this function returns NULL.
Parses the specified UTF8-encoded |json| buffer of size |json_size| and returns a dictionary or list representation. If JSON parsing fails this function returns NULL.
Parses the specified |json_string| and returns a dictionary or list representation. If JSON parsing fails this function returns NULL and populates |error_msg_out| with a formatted error message.
Parse the specified |url| into its component parts. Returns false (0) if the URL is NULL or invalid.
Create a new cef_post_data_t object.
Create a new cef_post_data_element_t object.
Post a task for delayed execution on the specified thread. Equivalent to using cef_task_runner_t::GetForThread(threadId)->PostDelayedTask(task, delay_ms).
Post a task for execution on the specified thread. Equivalent to using
Create a new cef_print_settings_t object.
Create a new cef_process_message_t object with the specified name.
Quit the CEF message loop that was started by calling cef_run_message_loop(). This function should only be called on the main application thread and only if cef_run_message_loop() was used.
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.
Register a scheme handler factory with the global request context. An NULL |domain_name| value for a standard scheme will cause the factory to match all domain names. The |domain_name| value will be ignored for non-standard schemes. If |scheme_name| is a built-in scheme and no handler is returned by |factory| then the built-in scheme handler factory will be called. If |scheme_name| is a custom scheme then you must also implement the
Remove an entry from the cross-origin access whitelist. Returns false (0) if |source_origin| is invalid or the whitelist cannot be accessed.
Creates a new context object with the specified |settings| and optional |handler|.
Returns the global context object.
Create a new cef_request_t object.
Returns the global resource bundle instance.
Create a new cef_response_t object.
Run the CEF message loop. Use this function instead of an application- provided message loop to get the best balance between performance and CPU usage. This function should only be called on the main application thread and only if cef_initialize() is called with a cef_settings_t.multi_threaded_message_loop value of false (0). This function will block until a quit message is received by the system.
Create a new server that binds to |address| and |port|. |address| must be a valid IPv4 or IPv6 address (e.g. 127.0.0.1 or ::1) and |port| must be a port number outside of the reserved range (e.g. between 1025 and 65535 on most platforms). |backlog| is the maximum number of pending connections. A new thread will be created for each CreateServer call (the "dedicated server thread"). It is therefore recommended to use a different cef_server_handler_t instance for each CreateServer call to avoid thread safety issues in the cef_server_handler_t implementation. The
Sets or clears a specific key-value pair from the crash metadata.
Set to true (1) before calling Windows APIs like TrackPopupMenu that enter a modal message loop. Set to false (0) after exiting the modal message loop.
Creates a new cef_shared_process_message_builder_t with the specified |name| and shared memory region of specified |byte_size|.
This function should be called on the main application thread to shut down the CEF browser process before the application exits.
Create a new cef_stream_reader_t object from data.
Create a new cef_stream_reader_t object from a file.
Create a new cef_stream_reader_t object from a custom handler.
Create a new cef_stream_writer_t object for a file.
Create a new cef_stream_writer_t object for a custom handler.
Returns the task runner for the current thread. Only CEF threads will have task runners. An NULL reference will be returned if this function is called on an invalid thread.
Returns the task runner for the specified CEF thread.
Create and start a new thread. This function does not block waiting for the thread to run initialization. |display_name| is the name that will be used to identify the thread. |priority| is the thread execution priority. |message_loop_type| indicates the set of asynchronous events that the thread can process. If |stoppable| is true (1) the thread will stopped and joined on destruction or when stop() is called; otherwise, the thread cannot be stopped and will be leaked on shutdown. On Windows the |com_init_mode| value specifies how COM will be initialized for the thread. If |com_init_mode| is set to COM_INIT_MODE_STA then |message_loop_type| must be set to ML_TYPE_UI.
Unescapes |text| and returns the result. Unescaping consists of looking for the exact pattern "%XX" where each X is a hex digit and converting to the character with the numerical value of those digits (e.g. "i%20=%203%3b" unescapes to "i = 3;"). If |convert_to_utf8| is true (1) this function will attempt to interpret the initial decoded result as UTF-8. If the result is convertable into UTF-8 it will be returned as converted. Otherwise the initial decoded result will be returned. The |unescape_rule| parameter supports further customization the decoding process.
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.
Create a new URL request that is not associated with a specific browser or frame. Use cef_frame_t::CreateURLRequest instead if you want the request to have this association, in which case it may be handled differently (see documentation on that function). A request created with this function may only originate from the browser process, and will behave as follows: - It may be intercepted by the client via CefResourceRequestHandler or CefSchemeHandlerFactory. - POST data may only contain only a single element of type PDE_TYPE_FILE or PDE_TYPE_BYTES. - If |request_context| is empty the global request context will be used.
Returns the current (top) context object in the V8 context stack.
Returns the entered (bottom) context object in the V8 context stack.
Returns true (1) if V8 is currently inside a context.
Returns the stack trace for the currently active context. |frame_limit| is the maximum number of frames that will be captured.
Create a new cef_v8value_t object of type array with the specified |length|. If |length| is negative the returned array will have length 0. This function should only be called from within the scope of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling enter() and exit() on a stored cef_v8context_t reference.
Create a new cef_v8value_t object of type ArrayBuffer which wraps the provided |buffer| of size |length| bytes. The ArrayBuffer is externalized, meaning that it does not own |buffer|. The caller is responsible for freeing |buffer| when requested via a call to cef_v8array_buffer_release_callback_t::ReleaseBuffer. This function should only be called from within the scope of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling enter() and exit() on a stored cef_v8context_t reference.
Create a new cef_v8value_t object of type bool.
Create a new cef_v8value_t object of type Date. This function should only be called from within the scope of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling enter() and exit() on a stored cef_v8context_t reference.
Create a new cef_v8value_t object of type double.
Create a new cef_v8value_t object of type function. This function should only be called from within the scope of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling enter() and exit() on a stored cef_v8context_t reference.
Create a new cef_v8value_t object of type int.
Create a new cef_v8value_t object of type null.
Create a new cef_v8value_t object of type object with optional accessor and/or interceptor. This function should only be called from within the scope of a cef_render_process_handler_t, cef_v8handler_t or cef_v8accessor_t callback, or in combination with calling enter() and exit() on a stored cef_v8context_t reference.
Create a new cef_v8value_t object of type string.
Create a new cef_v8value_t object of type unsigned int.
Create a new cef_v8value_t object of type undefined.
Creates a new object.
Create a new waitable event. If |automatic_reset| is true (1) then the event state is automatically reset to un-signaled after a single waiting thread has been released; otherwise, the state remains signaled until reset() is called manually. If |initially_signaled| is true (1) then the event will start in the signaled state.
Generates a JSON string from the specified root |node| which should be a dictionary or list value. Returns an NULL string on failure. This function requires exclusive access to |node| including any underlying data.
Create a new cef_xml_reader_t object. The returned object's functions can only be called from the thread that created the object.
Writes the contents of |src_dir| into a zip archive at |dest_file|. If |include_hidden_files| 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.
Create a new cef_zip_reader_t object. The returned object's functions can only be called from the thread that created the object.
A structure representing the information packed into the LPARAM given to a Win32 key event. See the documentation for WM_KEYDOWN for details at https://docs.microsoft.com/windows/win32/inputdev/wm-keydown
Implement this structure to receive accessibility notification when accessibility events have been registered. The functions of this structure will be called on the UI thread.
Implement this structure to provide handler implementations. Methods will be called by the process and/or thread indicated.
Implement this structure to handle audio events.
Structure representing the audio parameters for setting up the audio handler.
Callback structure used for asynchronous continuation of authentication requests.
Callback structure used to asynchronously continue a download.
Structure representing a binary value. Can be used on any process and thread.
Settings used when initializing a CefBoxLayout.
Structure used to represent the browser process aspects of a browser. The functions of this structure can only be called in the browser process. They may be called on any thread in that process unless otherwise indicated in the comments.
Structure used to implement browser process callbacks. The functions of this structure will be called on the browser process main thread unless otherwise indicated.
Browser initialization settings. Specify NULL or 0 to get the recommended default values. The consequences of using custom values may not be well tested. Many of these and other settings can also configured using command- line switches.
Structure used to represent a browser. When used in the browser process the functions of this structure may be called on any thread unless otherwise indicated in the comments. When used in the render process the functions of this structure may only be called on the main thread.
Generic callback structure used for asynchronous continuation.
Implement this structure to provide handler implementations.
Implement this structure to handle events related to commands. The functions of this structure will be called on the UI thread.
Structure used to create and/or parse command line arguments. Arguments with "--", "-" and, on Windows, "/" prefixes are considered switches. Switches will always precede any arguments without switch prefixes. Switches can optionally have a value specified using the "=" delimiter (e.g. "-switch=value"). An argument of "--" will terminate switch parsing with all subsequent tokens, regardless of prefix, being interpreted as non-switch arguments. Switch names should be lowercase ASCII and will be converted to such if necessary. Switch values will retain the original case and UTF8 encoding. This structure can be used before cef_initialize() is called.
Generic callback structure used for asynchronous completion.
Structure representing IME composition underline information. This is a thin wrapper around Blink's WebCompositionUnderline class and should be kept in sync with that.
Implement this structure to handle context menu events. The functions of this structure will be called on the UI thread.
Provides information about the context menu state. The functions of this structure can only be accessed on browser process the UI thread.
Implement this structure to filter cookies that may be sent or received from resource requests. The functions of this structure will be called on the IO thread unless otherwise indicated.
Structure used for managing cookies. The functions of this structure may be called on any thread unless otherwise indicated.
Cookie information.
Structure to implement for visiting cookie values. The functions of this structure will always be called on the UI thread.
Structure representing cursor information. |buffer| will be |size.width|*|size.height|*4 bytes in size and represents a BGRA image with an upper-left origin.
Structure to implement to be notified of asynchronous completion via
Callback structure for cef_browser_host_t::AddDevToolsMessageObserver. The functions of this structure will be called on the browser process UI thread.
Implement this structure to handle dialog events. The functions of this structure will be called on the browser process UI thread.
Structure representing a dictionary value. Can be used on any process and thread.
Implement this structure to handle events related to browser display state. The functions of this structure will be called on the UI thread.
Structure used to represent a DOM document. The functions of this structure should only be called on the render process main thread thread.
Structure used to represent a DOM node. The functions of this structure should only be called on the render process main thread.
Structure to implement for visiting the DOM. The functions of this structure will be called on the render process main thread.
Structure used to handle file downloads. The functions of this structure will called on the browser process UI thread.
Callback structure for cef_browser_host_t::DownloadImage. The functions of this structure will be called on the browser process UI thread.
Callback structure used to asynchronously cancel a download.
Structure used to represent a download item.
Structure used to represent drag data. The functions of this structure may be called on any thread.
Implement this structure to handle events related to dragging. The functions of this structure will be called on the UI thread.
Structure representing a draggable region.
Implement this structure to receive notification when tracing has completed. The functions of this structure will be called on the browser process UI thread.
Implement this structure to handle events related to browser extensions. The functions of this structure will be called on the UI thread. See
Object representing an extension. Methods may be called on any thread unless otherwise indicated.
Callback structure for asynchronous continuation of file dialog requests.
Implement this structure to handle events related to find results. The functions of this structure will be called on the UI thread.
Implement this structure to handle events related to focus. The functions of this structure will be called on the UI thread.
Implement this structure to handle events related to cef_frame_t life span. The order of callbacks is:
Structure used to represent a frame in the browser window. When used in the browser process the functions of this structure may be called on any thread unless otherwise indicated in the comments. When used in the render process the functions of this structure may only be called on the main thread.
Callback structure used for asynchronous continuation of
Container for a single image represented at different scale factors. All image representations should be the same size in density independent pixel (DIP) units. For example, if the image at scale factor 1.0 is 100x100 pixels then the image at scale factor 2.0 should be 200x200 pixels -- both images will display with a DIP size of 100x100 units. The functions of this structure can be called on any browser process thread.
Structure representing insets.
Callback structure used for asynchronous continuation of JavaScript dialog requests.
Implement this structure to handle events related to JavaScript dialogs. The functions of this structure will be called on the UI thread.
Structure representing keyboard event information.
Implement this structure to handle events related to keyboard input. The functions of this structure will be called on the UI thread.
Implement this structure to handle events related to browser life span. The functions of this structure will be called on the UI thread unless otherwise indicated.
Structure representing a list value. Can be used on any process and thread.
Implement this structure to handle events related to browser load status. The functions of this structure will be called on the browser process UI thread or render process main thread (TID_RENDERER).
Callback structure used for asynchronous continuation of media access permission requests.
Implemented by the client to observe MediaRouter events and registered via
Callback structure for cef_media_router_t::CreateRoute. The functions of this structure will be called on the browser process UI thread.
Represents the route between a media source and sink. Instances of this object are created via cef_media_router_t::CreateRoute and retrieved via
Supports discovery of and communication with media devices on the local network via the Cast and DIAL protocols. The functions of this structure may be called on any browser process thread unless otherwise indicated.
Callback structure for cef_media_sink_t::GetDeviceInfo. The functions of this structure will be called on the browser process UI thread.
Device information for a MediaSink object.
Represents a sink to which media can be routed. Instances of this object are retrieved via cef_media_observer_t::OnSinks. The functions of this structure 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 cef_media_router_t::GetSource. The functions of this structure may be called on any browser process thread unless otherwise indicated.
Implement this structure to handle menu model events. The functions of this structure will be called on the browser process UI thread unless otherwise indicated.
Supports creation and modification of menus. See cef_menu_id_t for the command ids that have default implementations. All user-defined command ids should be between MENU_ID_USER_FIRST and MENU_ID_USER_LAST. The functions of this structure can only be accessed on the browser process the UI thread.
Structure representing mouse event information.
Structure used to represent an entry in navigation history.
Callback structure for cef_browser_host_t::GetNavigationEntries. The functions of this structure will be called on the browser process UI thread.
Callback structure for cef_browser_host_t::PrintToPDF. The functions of this structure will be called on the browser process UI thread.
Structure representing PDF print settings.
Implement this structure to handle events related to permission requests. The functions of this structure will be called on the browser process UI thread.
Callback structure used for asynchronous continuation of permission prompts.
Structure representing a point.
Popup window features.
Structure used to represent a single element in the request post data. The functions of this structure may be called on any thread.
Structure used to represent post data for a web request. The functions of this structure may be called on any thread.
Callback structure for asynchronous continuation of print dialog requests.
Implement this structure to handle printing on Linux. Each browser will have only one print job in progress at a time. The functions of this structure will be called on the browser process UI thread.
Callback structure for asynchronous continuation of print job requests.
Structure representing print settings.
Structure representing a message. Can be used on any process and thread.
Structure representing a range.
Structure the client can implement to provide a custom stream reader. The functions of this structure may be called on any thread.
Structure representing a rectangle.
Generic callback structure used for managing the lifespan of a registration.
Implement this structure to handle events when window rendering is disabled. The functions of this structure will be called on the UI thread.
Structure used to implement render process callbacks. The functions of this structure will be called on the render process main thread (TID_RENDERER) unless otherwise indicated.
Implement this structure to provide handler implementations. The handler instance will not be released until all objects related to the context have been destroyed.
Request context initialization settings. Specify NULL or 0 to get the recommended default values.
A request context provides request handling for a set of related browser or URL request objects. A request context can be specified when creating a new browser via the cef_browser_host_t static factory functions or when creating a new URL request via the cef_urlrequest_t static factory functions. Browser objects with different request contexts will never be hosted in the same render process. Browser objects with the same request context may or may not be hosted in the same render process depending on the process model. Browser objects created indirectly via the JavaScript window.open function or targeted links will share the same render process and the same request context as the source browser. When running in single-process mode there is only a single render process (the main process) and so all browsers created in single-process mode will share the same request context. This will be the first request context passed into a cef_browser_host_t static factory function and all other request context objects will be ignored.
Implement this structure to handle events related to browser requests. The functions of this structure will be called on the thread indicated.
Structure used to represent a web request. The functions of this structure may be called on any thread.
Callback structure for cef_request_context_t::ResolveHost.
Structure used to implement a custom resource bundle structure. See CefSettings for additional options related to resource bundle loading. The functions of this structure may be called on multiple threads.
Structure used for retrieving resources from the resource bundle (*.pak) files loaded by CEF during startup or via the cef_resource_bundle_handler_t returned from cef_app_t::GetResourceBundleHandler. See CefSettings for additional options related to resource bundle loading. The functions of this structure may be called on any thread unless otherwise indicated.
Structure used to implement a custom request handler structure. The functions of this structure will be called on the IO thread unless otherwise indicated.
Callback for asynchronous continuation of cef_resource_handler_t::read().
Implement this structure to handle events related to browser requests. The functions of this structure will be called on the IO thread unless otherwise indicated.
Callback for asynchronous continuation of cef_resource_handler_t::skip().
Implement this structure to filter resource response content. The functions of this structure will be called on the browser process IO thread.
Structure used to represent a web response. The functions of this structure may be called on any thread.
Callback structure used for continuation of custom context menu display.
Callback structure for cef_browser_host_t::RunFileDialog. The functions of this structure will be called on the browser process UI thread.
Callback structure used for continuation of custom quick menu display.
Structure that creates cef_resource_handler_t instances for handling scheme requests. The functions of this structure will always be called on the IO thread.
Structure that manages custom scheme registrations.
Screen information used when window rendering is disabled. This structure is passed as a parameter to CefRenderHandler::GetScreenInfo and should be filled in by the client.
Callback structure used to select a client certificate for authentication.
Implement this structure to handle HTTP server requests. A new thread will be created for each cef_server_t::CreateServer call (the "dedicated server thread"), and the functions of this structure will be called on that thread. It is therefore recommended to use a different cef_server_handler_t instance for each cef_server_t::CreateServer call to avoid thread safety issues in the cef_server_handler_t implementation.
Structure representing a server that supports HTTP and WebSocket requests. Server capacity is limited and is intended to handle only a small number of simultaneous connections (e.g. for communicating between applications on localhost). The functions of this structure are safe to call from any thread in the brower process unless otherwise indicated.
Structure to implement to be notified of asynchronous completion via
Initialization settings. Specify NULL or 0 to get the recommended default values. Many of these and other settings can also configured using command- line switches.
Structure that wraps platform-dependent share memory region mapping.
Structure that builds a cef_process_message_t containing a shared memory region. This structure is not thread-safe but may be used exclusively on a different thread from the one which constructed it.
Structure representing a size.
Structure representing SSL information.
Structure representing the SSL information for a navigation entry.
Structure used to read data from a stream. The functions of this structure may be called on any thread.
Structure used to write data to a stream. The functions of this structure may be called on any thread.
Implement this structure to receive string values asynchronously.
Structure that asynchronously executes tasks on the associated thread. It is safe to call the functions of this structure on any thread.
Implement this structure 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.
A simple thread abstraction that establishes a message loop on a new thread. The consumer uses cef_task_runner_t to execute code on the thread's message loop. The thread is terminated when the cef_thread_t 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 structure 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.
Structure representing touch event information.
URL component parts.
Structure that should be implemented by the cef_urlrequest_t client. The functions of this structure will be called on the same thread that created the request unless otherwise documented.
Structure used to make a URL request. URL requests are not associated with a browser instance so no cef_client_t 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.
Structure that should be implemented to handle V8 accessor calls. Accessor identifiers are registered by calling cef_v8value_t::set_value(). The functions of this structure will be called on the thread associated with the V8 accessor.
Callback structure that is passed to cef_v8value_t::CreateArrayBuffer.
Structure representing a V8 context 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 cef_v8context_t::get_task_runner() function.
Structure representing a V8 exception. The functions of this structure may be called on any render process thread.
Structure that should be implemented to handle V8 function calls. The functions of this structure will be called on the thread associated with the V8 function.
Structure that should be implemented to handle V8 interceptor calls. The functions of this structure 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.
Structure representing a V8 stack frame 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 cef_v8context_t::get_task_runner() function.
Structure 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 cef_v8context_t::get_task_runner() function.
Structure representing a V8 value 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 cef_v8context_t::get_task_runner() function.
Structure 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.
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.
Structure the client can implement to provide a custom stream writer. The functions of this structure may be called on any thread.
Structure representing the issuer or subject field of an X.509 certificate.
Structure representing a X.509 certificate.
Structure that supports the reading of XML data via the libxml streaming API. The functions of this structure should only be called on the thread that creates the object.
Structure that supports the reading of zip archives via the zlib unzip API. The functions of this structure should only be called on the thread that creates the object.
This gives access to the CEF functions. If you get a linker error for using an undefined function, it is probably because you did NOT go through this when dynamically loading.
WebView2 enables you to host web content using the latest Edge web browser technology.
Event args for the AcceleratorKeyPressed event.
The caller implements this interface to receive the AcceleratorKeyPressed event.
The caller implements this interface to receive the result of the AddScriptToExecuteOnDocumentCreated method.
The caller implements this interface to receive CallDevToolsProtocolMethod completion results.
The caller implements this method to receive the result of the CapturePreview method. The result is written to the stream provided in the CapturePreview method call.
The caller implements this method to receive the ContainsFullScreenElementChanged events. There are no event args for this event.
Event args for the ContentLoading event.
The caller implements this interface to receive the ContentLoading event.
This interface is the owner of the CoreWebView2 object, and provides support for resizing, showing and hiding, focusing, and other functionality related to windowing and composition. The CoreWebView2Controller owns the CoreWebView2, and if all references to the CoreWebView2Controller go away, the WebView will be closed.
The caller implements this interface to receive the CoreWebView2Controller created via CreateCoreWebView2Controller.
The caller implements this interface to receive the WebView2Environment created via CreateCoreWebView2Environment.
This interface is used to complete deferrals on event args that support getting deferrals via their GetDeferral method.
Event args for the DevToolsProtocolEventReceived event.
The caller implements this interface to receive DevToolsProtocolEventReceived events from the WebView.
A Receiver is created for a particular DevTools Protocol event and allows you to subscribe and unsubscribe from that event. Obtained from the WebView object via GetDevToolsProtocolEventReceiver.
The caller implements this interface to receive DocumentTitleChanged events. Use the DocumentTitle property to get the modified title.
This represents the WebView2 Environment. WebViews created from an environment run on the browser process specified with environment parameters and objects created from an environment should be used in the same environment. Using it in different environments are not guaranteed to be compatible and may fail.
Options used to create WebView2 Environment.
The caller implements this interface to receive the result of the ExecuteScript method.
The caller implements this method to receive the GotFocus and LostFocus events. There are no event args for this event.
The caller implements this interface to receive the HistoryChanged event.
Iterator for a collection of HTTP headers. See ICoreWebView2HttpRequestHeaders and ICoreWebView2HttpResponseHeaders.
HTTP request headers. Used to inspect the HTTP request on WebResourceRequested event and NavigationStarting event. Note, you can modify the HTTP request headers from a WebResourceRequested event, but not from a NavigationStarting event.
HTTP response headers. Used to construct a WebResourceResponse for the WebResourceRequested event.
Event args for the MoveFocusRequested event.
The caller implements this method to receive the MoveFocusRequested event.
Event args for the NavigationCompleted event.
The caller implements this interface to receive the NavigationCompleted event.
Event args for the NavigationStarting event.
The caller implements this interface to receive the NavigationStarting event.
The caller implements this interface to receive NewBrowserVersionAvailable events.
Event args for the NewWindowRequested event. The event is fired when content inside webview requested to a open a new window (through window.open() and so on.)
The caller implements this interface to receive NewWindowRequested events.
Event args for the PermissionRequested event.
The caller implements this interface to receive the PermissionRequested event.
Event args for the ProcessFailed event.
The caller implements this interface to receive ProcessFailed events.
Event args for the ScriptDialogOpening event.
The caller implements this interface to receive the ScriptDialogOpening event.
Defines properties that enable, disable, or modify WebView features. Setting changes made after NavigationStarting event will not apply until the next top level navigation.
Event args for the SourceChanged event.
The caller implements this interface to receive the SourceChanged event.
Event args for the WebMessageReceived event.
The caller implements this interface to receive the WebMessageReceived event.
An HTTP request used with the WebResourceRequested event.
Event args for the WebResourceRequested event.
Fires when a URL request (through network, file etc.) is made in the webview for a Web resource matching resource context filter and URL specified in AddWebResourceRequestedFilter. The host can view and modify the request or provide a response in a similar pattern to HTTP, in which case the request immediately completed. This may not contain any request headers that are added by the network stack, such as Authorization headers.
An HTTP response used with the WebResourceRequested event.
The caller implements this interface to receive NewWindowRequested events.
Window features for a WebView popup window. These fields match the 'windowFeatures' passed to window.open as specified in https://developer.mozilla.org/en-US/docs/Web/API/Window/open#Window_features
There is no requirement for you to respect these values. If your app doesn't have corresponding UI features, for example no toolbar, or if all webviews are opened in tabs and so cannot have distinct size or positions, then your app cannot respect these values. You may want to respect values but perhaps only some can apply to your app's UI. Accordingly, it is fine to respect all, some, or none of these properties as appropriate based on your app. For all numeric properties, if the value when passed to window.open is outside the range of an unsigned 32bit int, the value will be mod of the max of unsigned 32bit integer. If the value cannot be parsed as an integer it will be considered 0. If the value is a floating point value, it will be rounded down to an integer.
The caller implements this interface to receive ZoomFactorChanged events. Use the ICoreWebView2Controller.ZoomFactor property to get the modified zoom factor.
I currently built against 95.7.17+g4208276+chromium-95.0.4638.69 and it uses UTF-16 strings.
cef_binary_107.1.9+g1f0a21a+chromium-107.0.5304.110_linux64_minimal.tar.bz2
Note my ceftranslate.d for instructions to start the update process.
Then to install the cef put in the Resources in the Release directory (*.pak and *.dat out of Resources, failure to do this will cause an abort on ICU file descriptor things) and copy the locales to /opt/cef/Resources/Locales
You can download compatible builds from https://cef-builds.spotifycdn.com/index.html just make sure to put in the version filter and check "all builds" to match it.
You do NOT actually need the cef to build the application, but it must be on the user's machine to run it. It looks in /opt/cef/ on Linux.
Work in progress. DO NOT USE YET as I am prolly gonna break everything too.
On Windows, you need to distribute the WebView2Loader.dll with your exe. That is found in the web view 2 sdk. Furthermore, users will have to install the runtime.
Please note; the Microsoft terms and conditions say they may be able to collect information about your users if you use this on Windows. see: https://developer.microsoft.com/en-us/microsoft-edge/webview2/
A web view wrapper. Uses CEF on Linux and WebView2 on Windows.
Microsoft WebView2 is fairly stable and is unlikely to break, but CEF is not remotely stable and likely to break every release. You'll have to get the same version as me to use this unless you want to generate your own bindings (procedure found in the file comments). Details below.