Overview   Project   Class   Tree   Index 
CEF3 C++ API Docs - Version 75.1.4+g4210896+chromium-75.0.3770.100
FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD

(default)
( globals)

   in cef_logging.h
   in cef_macros.h
   in cef_ref_counted.h
   in cef_scoped_ptr.h
   in cef_api_hash.h
   in cef_app.h
   in cef_crash_util.h
   in cef_file_util.h
   in cef_origin_whitelist.h
   in cef_parser.h
   in cef_path_util.h
   in cef_process_util.h
   in cef_sandbox_win.h
   in cef_scheme.h
   in cef_ssl_info.h
   in cef_task.h
   in cef_trace.h
   in cef_v8.h
   in cef_version.h
   in cef_web_plugin.h
   in cef_logging_internal.h
   in cef_string_list.h
   in cef_string_map.h
   in cef_string_multimap.h
   in cef_string_types.h
   in cef_thread_internal.h
   in cef_time.h
   in cef_trace_event_internal.h
   in cef_types_wrappers.h
   in cef_test_helpers.h
   in cef_closure_task.h
   in cef_library_loader.h

( globals)


Method Summary
 CEF_EXPORT const char* cef_api_hash( int entry )
          Returns CEF API hashes for the libcef library.
 CEF_EXPORT cef_platform_thread_handle_t cef_get_current_platform_thread_handle()
          Returns the current platform thread handle.
 CEF_EXPORT cef_platform_thread_id_t cef_get_current_platform_thread_id()
          Returns the current platform thread ID.
 CEF_EXPORT int cef_get_min_log_level()
          Gets the current log level.
 CEF_EXPORT int cef_get_vlog_level( const char* file_start, size_t N )
          Gets the current vlog level for the given file (usually taken from __FILE__).
 int cef_load_library( const char* path )
          Load the CEF library at the specified |path|.
 CEF_EXPORT void cef_log( const char* file, int line, int severity, const char* message )
          Add a log message.
 void* cef_sandbox_info_create()
          Create the sandbox information object for this process.
 void cef_sandbox_info_destroy( void* sandbox_info )
          Destroy the specified sandbox information object.
 CEF_EXPORT int cef_string_ascii_to_utf16( const char* src, size_t src_len, cef_string_utf16_t* output )
          
 CEF_EXPORT int cef_string_ascii_to_wide( const char* src, size_t src_len, cef_string_wide_t* output )
          These functions convert an ASCII string, typically a hardcoded constant, to a Wide/UTF16 string.
 CEF_EXPORT cef_string_list_t cef_string_list_alloc()
          Allocate a new string map.
 CEF_EXPORT void cef_string_list_append( cef_string_list_t list, const cef_string_t* value )
          Append a new value at the end of the string list.
 CEF_EXPORT void cef_string_list_clear( cef_string_list_t list )
          Clear the string list.
 CEF_EXPORT cef_string_list_t cef_string_list_copy( cef_string_list_t list )
          Creates a copy of an existing string list.
 CEF_EXPORT void cef_string_list_free( cef_string_list_t list )
          Free the string list.
 CEF_EXPORT size_t cef_string_list_size( cef_string_list_t list )
          Return the number of elements in the string list.
 CEF_EXPORT int cef_string_list_value( cef_string_list_t list, size_t index, cef_string_t* value )
          Retrieve the value at the specified zero-based string list index.
 CEF_EXPORT cef_string_map_t cef_string_map_alloc()
          Allocate a new string map.
 CEF_EXPORT int cef_string_map_append( cef_string_map_t map, const cef_string_t* key, const cef_string_t* value )
          Append a new key/value pair at the end of the string map.
 CEF_EXPORT void cef_string_map_clear( cef_string_map_t map )
          Clear the string map.
 CEF_EXPORT int cef_string_map_find( cef_string_map_t map, const cef_string_t* key, cef_string_t* value )
          Return the value assigned to the specified key.
 CEF_EXPORT void cef_string_map_free( cef_string_map_t map )
          Free the string map.
 CEF_EXPORT int cef_string_map_key( cef_string_map_t map, size_t index, cef_string_t* key )
          Return the key at the specified zero-based string map index.
 CEF_EXPORT size_t cef_string_map_size( cef_string_map_t map )
          Return the number of elements in the string map.
 CEF_EXPORT int cef_string_map_value( cef_string_map_t map, size_t index, cef_string_t* value )
          Return the value at the specified zero-based string map index.
 CEF_EXPORT cef_string_multimap_t cef_string_multimap_alloc()
          Allocate a new string multimap.
 CEF_EXPORT int cef_string_multimap_append( cef_string_multimap_t map, const cef_string_t* key, const cef_string_t* value )
          Append a new key/value pair at the end of the string multimap.
 CEF_EXPORT void cef_string_multimap_clear( cef_string_multimap_t map )
          Clear the string multimap.
 CEF_EXPORT int cef_string_multimap_enumerate( cef_string_multimap_t map, const cef_string_t* key, size_t value_index, cef_string_t* value )
          Return the value_index-th value with the specified key.
 CEF_EXPORT size_t cef_string_multimap_find_count( cef_string_multimap_t map, const cef_string_t* key )
          Return the number of values with the specified key.
 CEF_EXPORT void cef_string_multimap_free( cef_string_multimap_t map )
          Free the string multimap.
 CEF_EXPORT int cef_string_multimap_key( cef_string_multimap_t map, size_t index, cef_string_t* key )
          Return the key at the specified zero-based string multimap index.
 CEF_EXPORT size_t cef_string_multimap_size( cef_string_multimap_t map )
          Return the number of elements in the string multimap.
 CEF_EXPORT int cef_string_multimap_value( cef_string_multimap_t map, size_t index, cef_string_t* value )
          Return the value at the specified zero-based string multimap index.
 CEF_EXPORT cef_string_userfree_utf16_t cef_string_userfree_utf16_alloc()
          
 CEF_EXPORT void cef_string_userfree_utf16_free( cef_string_userfree_utf16_t str )
          
 CEF_EXPORT cef_string_userfree_utf8_t cef_string_userfree_utf8_alloc()
          
 CEF_EXPORT void cef_string_userfree_utf8_free( cef_string_userfree_utf8_t str )
          
 CEF_EXPORT cef_string_userfree_wide_t cef_string_userfree_wide_alloc()
          These functions allocate a new string structure.
 CEF_EXPORT void cef_string_userfree_wide_free( cef_string_userfree_wide_t str )
          These functions free the string structure allocated by the associated alloc function.
 CEF_EXPORT void cef_string_utf16_clear( cef_string_utf16_t* str )
          
 CEF_EXPORT int cef_string_utf16_cmp( const cef_string_utf16_t* str1, const cef_string_utf16_t* str2 )
          
 CEF_EXPORT int cef_string_utf16_set( const char16* src, size_t src_len, cef_string_utf16_t* output, int copy )
          
 CEF_EXPORT int cef_string_utf16_to_lower( const char16* src, size_t src_len, cef_string_utf16_t* output )
          These functions convert utf16 string case using the current ICU locale.
 CEF_EXPORT int cef_string_utf16_to_upper( const char16* src, size_t src_len, cef_string_utf16_t* output )
          
 CEF_EXPORT int cef_string_utf16_to_utf8( const char16* src, size_t src_len, cef_string_utf8_t* output )
          
 CEF_EXPORT int cef_string_utf16_to_wide( const char16* src, size_t src_len, cef_string_wide_t* output )
          
 CEF_EXPORT void cef_string_utf8_clear( cef_string_utf8_t* str )
          
 CEF_EXPORT int cef_string_utf8_cmp( const cef_string_utf8_t* str1, const cef_string_utf8_t* str2 )
          
 CEF_EXPORT int cef_string_utf8_set( const char* src, size_t src_len, cef_string_utf8_t* output, int copy )
          
 CEF_EXPORT int cef_string_utf8_to_utf16( const char* src, size_t src_len, cef_string_utf16_t* output )
          
 CEF_EXPORT int cef_string_utf8_to_wide( const char* src, size_t src_len, cef_string_wide_t* output )
          
 CEF_EXPORT void cef_string_wide_clear( cef_string_wide_t* str )
          These functions clear string values.
 CEF_EXPORT int cef_string_wide_cmp( const cef_string_wide_t* str1, const cef_string_wide_t* str2 )
          These functions compare two string values with the same results as strcmp().
 CEF_EXPORT int cef_string_wide_set( const wchar_t* src, size_t src_len, cef_string_wide_t* output, int copy )
          These functions set string values.
 CEF_EXPORT int cef_string_wide_to_utf16( const wchar_t* src, size_t src_len, cef_string_utf16_t* output )
          
 CEF_EXPORT int cef_string_wide_to_utf8( const wchar_t* src, size_t src_len, cef_string_utf8_t* output )
          These functions convert between UTF-8, -16, and -32 strings.
 CEF_EXPORT int cef_time_delta( const cef_time_t* cef_time1, const cef_time_t* cef_time2, long long* delta )
          Retrieve the delta in milliseconds between two time values.
 CEF_EXPORT int cef_time_from_doublet( double time, cef_time_t* cef_time )
          
 CEF_EXPORT int cef_time_from_timet( time_t time, cef_time_t* cef_time )
          
 CEF_EXPORT int cef_time_now( cef_time_t* cef_time )
          Retrieve the current system time.
 CEF_EXPORT int cef_time_to_doublet( const cef_time_t* cef_time, double* time )
          Converts cef_time_t to/from a double which is the number of seconds since epoch (Jan 1, 1970).
 CEF_EXPORT int cef_time_to_timet( const cef_time_t* cef_time, time_t* time )
          Converts cef_time_t to/from time_t.
 CEF_EXPORT void cef_trace_counter( const char* category, const char* name, const char* value1_name, uint64 value1_val, const char* value2_name, uint64 value2_val, int copy )
          
 CEF_EXPORT void cef_trace_counter_id( const char* category, const char* name, uint64 id, const char* value1_name, uint64 value1_val, const char* value2_name, uint64 value2_val, int copy )
          
 CEF_EXPORT void cef_trace_event_async_begin( const char* category, const char* name, uint64 id, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy )
          
 CEF_EXPORT void cef_trace_event_async_end( const char* category, const char* name, uint64 id, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy )
          
 CEF_EXPORT void cef_trace_event_async_step_into( const char* category, const char* name, uint64 id, uint64 step, const char* arg1_name, uint64 arg1_val, int copy )
          
 CEF_EXPORT void cef_trace_event_async_step_past( const char* category, const char* name, uint64 id, uint64 step, const char* arg1_name, uint64 arg1_val, int copy )
          
 CEF_EXPORT void cef_trace_event_begin( const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy )
          
 CEF_EXPORT void cef_trace_event_end( const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy )
          
 CEF_EXPORT void cef_trace_event_instant( const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy )
          
 int cef_unload_library()
          Unload the CEF library that was previously loaded.
 CEF_EXPORT int cef_version_info( int entry )
          
 bool CefAddCrossOriginWhitelistEntry( const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains )
          Add an entry to the cross-origin access whitelist.
 CefRefPtr< CefBinaryValue > CefBase64Decode( const CefString& data )
          Decodes the base64 encoded string |data|.
 CefString CefBase64Encode( const void* data, size_t data_size )
          Encodes |data| as a base64 string.
 bool CefBeginTracing( const CefString& categories, CefRefPtr< CefCompletionCallback > callback )
          Start tracing events on all processes.
 bool CefClearCrossOriginWhitelist()
          Remove all entries from the cross-origin access whitelist.
 bool CefClearSchemeHandlerFactories()
          Clear all scheme handler factories registered with the global request context.
 bool CefCrashReportingEnabled()
          Crash reporting is configured using an INI-style config file named "crash_reporter.cfg".
 CefRefPtr< CefTask > CefCreateClosureTask( const base::Closure& closure )
          Create a CefTask that wraps a base::Closure.
 bool CefCreateDirectory( const CefString& full_path )
          Creates a directory and all parent directories if they don't already exist.
 bool CefCreateNewTempDirectory( const CefString& prefix, CefString& new_temp_path )
          Creates a new directory.
 bool CefCreateTempDirectoryInDirectory( const CefString& base_dir, const CefString& prefix, CefString& new_dir )
          Creates a directory within another directory.
 bool CefCreateURL( const CefURLParts& parts, CefString& url )
          Creates a URL from the specified |parts|, which must contain a non-empty spec or a non-empty host and path (at a minimum), but not both.
 bool CefCurrentlyOn( CefThreadId threadId )
          Returns true if called on the specified thread.
 bool CefDeleteFile( const CefString& path, bool recursive )
          Deletes the given path whether it's a file or a directory.
 bool CefDirectoryExists( const CefString& path )
          Returns true if the given path exists and is a directory.
 void CefDoMessageLoopWork()
          Perform a single iteration of CEF message loop processing.
 void CefEnableHighDPISupport()
          Call during process startup to enable High-DPI support on Windows 7 or newer.
 bool CefEndTracing( const CefString& tracing_file, CefRefPtr< CefEndTracingCallback > callback )
          Stop tracing events on all processes.
 void CefExecuteJavaScriptWithUserGestureForTests( CefRefPtr< CefFrame > frame, const CefString& javascript )
          Execute JavaScript with a user gesture to trigger functionality like onbeforeunload handlers that will otherwise be blocked.
 int CefExecuteProcess( const CefMainArgs& args, CefRefPtr< CefApp > application, void* windows_sandbox_info )
          This function should be called from the application entry point function to execute a secondary process.
 CefString CefFormatUrlForSecurityDisplay( const CefString& origin_url )
          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).
 void CefGetExtensionsForMimeType( const CefString& mime_type, std::vector< CefString >& extensions )
          Get the extensions associated with the given mime type.
 CefString CefGetMimeType( const CefString& extension )
          Returns the mime type for the specified file extension or an empty string if unknown.
 bool CefGetPath( PathKey key, CefString& path )
          Retrieve the path associated with the specified |key|.
 bool CefGetTempDirectory( CefString& temp_dir )
          Get the temporary directory provided by the system.
 bool CefInitialize( const CefMainArgs& args, const CefSettings& settings, CefRefPtr< CefApp > application, void* windows_sandbox_info )
          This function should be called on the main application thread to initialize the CEF browser process.
 bool CefIsCertStatusError( cef_cert_status_t status )
          Returns true if the certificate status has any error, major or minor.
 bool CefIsCertStatusMinorError( cef_cert_status_t status )
          Returns true if the certificate status represents only minor errors (e.g. failure to verify certificate revocation).
 void CefIsWebPluginUnstable( const CefString& path, CefRefPtr< CefWebPluginUnstableCallback > callback )
          Query if a plugin is unstable.
 bool CefLaunchProcess( CefRefPtr< CefCommandLine > command_line )
          Launches the process specified via |command_line|.
 void CefLoadCRLSetsFile( const CefString& path )
          Loads the existing "Certificate Revocation Lists" file that is managed by Google Chrome.
 int64 CefNowFromSystemTraceTime()
          Returns the current system trace time or, if none is defined, the current high-res time.
 CefRefPtr< CefValue > CefParseJSON( const CefString& json_string, cef_json_parser_options_t options )
          Parses the specified |json_string| and returns a dictionary or list representation.
 CefRefPtr< CefValue > CefParseJSONAndReturnError( const CefString& json_string, cef_json_parser_options_t options, cef_json_parser_error_t& error_code_out, CefString& error_msg_out )
          Parses the specified |json_string| and returns a dictionary or list representation.
 bool CefParseURL( const CefString& url, CefURLParts& parts )
          Parse the specified |url| into its component parts.
 bool CefPostDelayedTask( CefThreadId threadId, const base::Closure& closure, int64 delay_ms )
          Post a Closure for delayed execution on the specified thread.
 bool CefPostDelayedTask( CefThreadId threadId, CefRefPtr< CefTask > task, int64 delay_ms )
          Post a task for delayed execution on the specified thread.
 bool CefPostTask( CefThreadId threadId, CefRefPtr< CefTask > task )
          Post a task for execution on the specified thread.
 bool CefPostTask( CefThreadId threadId, const base::Closure& closure )
          Post a Closure for execution on the specified thread.
 void CefQuitMessageLoop()
          Quit the CEF message loop that was started by calling CefRunMessageLoop().
 void CefRefreshWebPlugins()
          Cause the plugin list to refresh the next time it is accessed regardless of whether it has already been loaded.
 bool CefRegisterExtension( const CefString& extension_name, const CefString& javascript_code, CefRefPtr< CefV8Handler > handler )
          Register a new V8 extension with the specified JavaScript extension code and handler.
 bool CefRegisterSchemeHandlerFactory( const CefString& scheme_name, const CefString& domain_name, CefRefPtr< CefSchemeHandlerFactory > factory )
          Register a scheme handler factory with the global request context.
 void CefRegisterWebPluginCrash( const CefString& path )
          Register a plugin crash.
 void CefRegisterWidevineCdm( const CefString& path, CefRefPtr< CefRegisterCdmCallback > callback )
          Register the Widevine CDM plugin.
 bool CefRemoveCrossOriginWhitelistEntry( const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains )
          Remove an entry from the cross-origin access whitelist.
 void CefRunMessageLoop()
          Run the CEF message loop.
 void CefSetCrashKeyValue( const CefString& key, const CefString& value )
          Sets or clears a specific key-value pair from the crash metadata.
 void CefSetOSModalLoop( bool osModalLoop )
          Set to true before calling Windows APIs like TrackPopupMenu that enter a modal message loop.
 void CefShutdown()
          This function should be called on the main application thread to shut down the CEF browser process before the application exits.
 void CefUnregisterInternalWebPlugin( const CefString& path )
          Unregister an internal plugin.
 CefString CefURIDecode( const CefString& text, bool convert_to_utf8, cef_uri_unescape_rule_t unescape_rule )
          Unescapes |text| and returns the result.
 CefString CefURIEncode( const CefString& text, bool use_plus )
          Escapes characters in |text| which are unsuitable for use as a query parameter value.
 void CefVisitWebPluginInfo( CefRefPtr< CefWebPluginInfoVisitor > visitor )
          Visit web plugin information.
 CefString CefWriteJSON( CefRefPtr< CefValue > node, cef_json_writer_options_t options )
          Generates a JSON string from the specified root |node| which should be a dictionary or list value.
 bool CefZipDirectory( const CefString& src_dir, const CefString& dest_file, bool include_hidden_files )
          Writes the contents of |src_dir| into a zip archive at |dest_file|.
 template< typename T, size_t N >[ N] char(& ArraySizeHelper( const T(& array )[ N] ) )
          
 template< typename T > scoped_ptr< T > make_scoped_ptr( T* ptr )
          
 template< typename T > scoped_refptr< T > make_scoped_refptr( T* t )
          
 inline bool operator!=( const CefPoint& a, const CefPoint& b )
          
 template< class T, class D > bool operator!=( T* p1, const scoped_ptr< T, D >& p2 )
          
 inline bool operator!=( const CefRect& a, const CefRect& b )
          
 inline bool operator!=( const CefDraggableRegion& a, const CefDraggableRegion& b )
          
 inline bool operator!=( const CefSize& a, const CefSize& b )
          
 inline bool operator!=( const CefRange& a, const CefRange& b )
          
 inline bool operator!=( const CefInsets& a, const CefInsets& b )
          
 std::ostream& operator<<( std::ostream& out, const wchar_t* wstr )
          
 inline std::ostream& operator<<( std::ostream& out, const std::wstring& wstr )
          
 inline bool operator==( const CefDraggableRegion& a, const CefDraggableRegion& b )
          
 inline bool operator==( const CefRange& a, const CefRange& b )
          
 inline bool operator==( const CefInsets& a, const CefInsets& b )
          
 inline bool operator==( const CefSize& a, const CefSize& b )
          
 inline bool operator==( const CefRect& a, const CefRect& b )
          
 inline bool operator==( const CefPoint& a, const CefPoint& b )
          
 template< class T, class D > bool operator==( T* p1, const scoped_ptr< T, D >& p2 )
          
 template< class T, class D > void swap( scoped_ptr< T, D >& p1, scoped_ptr< T, D >& p2 )
          
 

Method Detail

cef_api_hash

 CEF_EXPORT const char* cef_api_hash( int entry );
Returns CEF API hashes for the libcef library. The returned string is owned by the library and should not be freed. The |entry| parameter describes which hash value will be returned: 0 - CEF_API_HASH_PLATFORM 1 - CEF_API_HASH_UNIVERSAL 2 - CEF_COMMIT_HASH (from cef_version.h)

cef_get_current_platform_thread_handle

 CEF_EXPORT cef_platform_thread_handle_t cef_get_current_platform_thread_handle();
Returns the current platform thread handle.

cef_get_current_platform_thread_id

 CEF_EXPORT cef_platform_thread_id_t cef_get_current_platform_thread_id();
Returns the current platform thread ID.

cef_get_min_log_level

 CEF_EXPORT int cef_get_min_log_level();
Gets the current log level.

cef_get_vlog_level

 CEF_EXPORT int cef_get_vlog_level( const char* file_start, size_t N );
Gets the current vlog level for the given file (usually taken from __FILE__). Note that |N| is the size *with* the null terminator.

cef_load_library

 int cef_load_library( const char* path );
Load the CEF library at the specified |path|. Returns true (1) on success and false (0) on failure.

cef_log

 CEF_EXPORT void cef_log( const char* file, int line, int severity, const char* message );
Add a log message. See the LogSeverity defines for supported |severity| values.

cef_sandbox_info_create

 void* cef_sandbox_info_create();
Create the sandbox information object for this process. It is safe to create multiple of this object and to destroy the object immediately after passing into the CefExecutProcess() and/or CefInitialize() functions.

cef_sandbox_info_destroy

 void cef_sandbox_info_destroy( void* sandbox_info );
Destroy the specified sandbox information object.

cef_string_ascii_to_utf16

 CEF_EXPORT int cef_string_ascii_to_utf16( const char* src, size_t src_len, cef_string_utf16_t* output );

cef_string_ascii_to_wide

 CEF_EXPORT int cef_string_ascii_to_wide( const char* src, size_t src_len, cef_string_wide_t* output );
These functions convert an ASCII string, typically a hardcoded constant, to a Wide/UTF16 string. Use instead of the UTF8 conversion routines if you know the string is ASCII.

cef_string_list_alloc

 CEF_EXPORT cef_string_list_t cef_string_list_alloc();
Allocate a new string map.

cef_string_list_append

 CEF_EXPORT void cef_string_list_append( cef_string_list_t list, const cef_string_t* value );
Append a new value at the end of the string list.

cef_string_list_clear

 CEF_EXPORT void cef_string_list_clear( cef_string_list_t list );
Clear the string list.

cef_string_list_copy

 CEF_EXPORT cef_string_list_t cef_string_list_copy( cef_string_list_t list );
Creates a copy of an existing string list.

cef_string_list_free

 CEF_EXPORT void cef_string_list_free( cef_string_list_t list );
Free the string list.

cef_string_list_size

 CEF_EXPORT size_t cef_string_list_size( cef_string_list_t list );
Return the number of elements in the string list.

cef_string_list_value

 CEF_EXPORT int cef_string_list_value( cef_string_list_t list, size_t index, cef_string_t* value );
Retrieve the value at the specified zero-based string list index. Returns true (1) if the value was successfully retrieved.

cef_string_map_alloc

 CEF_EXPORT cef_string_map_t cef_string_map_alloc();
Allocate a new string map.

cef_string_map_append

 CEF_EXPORT int cef_string_map_append( cef_string_map_t map, const cef_string_t* key, const cef_string_t* value );
Append a new key/value pair at the end of the string map.

cef_string_map_clear

 CEF_EXPORT void cef_string_map_clear( cef_string_map_t map );
Clear the string map.

cef_string_map_find

 CEF_EXPORT int cef_string_map_find( cef_string_map_t map, const cef_string_t* key, cef_string_t* value );
Return the value assigned to the specified key.

cef_string_map_free

 CEF_EXPORT void cef_string_map_free( cef_string_map_t map );
Free the string map.

cef_string_map_key

 CEF_EXPORT int cef_string_map_key( cef_string_map_t map, size_t index, cef_string_t* key );
Return the key at the specified zero-based string map index.

cef_string_map_size

 CEF_EXPORT size_t cef_string_map_size( cef_string_map_t map );
Return the number of elements in the string map.

cef_string_map_value

 CEF_EXPORT int cef_string_map_value( cef_string_map_t map, size_t index, cef_string_t* value );
Return the value at the specified zero-based string map index.

cef_string_multimap_alloc

 CEF_EXPORT cef_string_multimap_t cef_string_multimap_alloc();
Allocate a new string multimap.

cef_string_multimap_append

 CEF_EXPORT int cef_string_multimap_append( cef_string_multimap_t map, const cef_string_t* key, const cef_string_t* value );
Append a new key/value pair at the end of the string multimap.

cef_string_multimap_clear

 CEF_EXPORT void cef_string_multimap_clear( cef_string_multimap_t map );
Clear the string multimap.

cef_string_multimap_enumerate

 CEF_EXPORT int cef_string_multimap_enumerate( cef_string_multimap_t map, const cef_string_t* key, size_t value_index, cef_string_t* value );
Return the value_index-th value with the specified key.

cef_string_multimap_find_count

 CEF_EXPORT size_t cef_string_multimap_find_count( cef_string_multimap_t map, const cef_string_t* key );
Return the number of values with the specified key.

cef_string_multimap_free

 CEF_EXPORT void cef_string_multimap_free( cef_string_multimap_t map );
Free the string multimap.

cef_string_multimap_key

 CEF_EXPORT int cef_string_multimap_key( cef_string_multimap_t map, size_t index, cef_string_t* key );
Return the key at the specified zero-based string multimap index.

cef_string_multimap_size

 CEF_EXPORT size_t cef_string_multimap_size( cef_string_multimap_t map );
Return the number of elements in the string multimap.

cef_string_multimap_value

 CEF_EXPORT int cef_string_multimap_value( cef_string_multimap_t map, size_t index, cef_string_t* value );
Return the value at the specified zero-based string multimap index.

cef_string_userfree_utf16_alloc

 CEF_EXPORT cef_string_userfree_utf16_t cef_string_userfree_utf16_alloc();

cef_string_userfree_utf16_free

 CEF_EXPORT void cef_string_userfree_utf16_free( cef_string_userfree_utf16_t str );

cef_string_userfree_utf8_alloc

 CEF_EXPORT cef_string_userfree_utf8_t cef_string_userfree_utf8_alloc();

cef_string_userfree_utf8_free

 CEF_EXPORT void cef_string_userfree_utf8_free( cef_string_userfree_utf8_t str );

cef_string_userfree_wide_alloc

 CEF_EXPORT cef_string_userfree_wide_t cef_string_userfree_wide_alloc();
These functions allocate a new string structure. They must be freed by calling the associated free function.

cef_string_userfree_wide_free

 CEF_EXPORT void cef_string_userfree_wide_free( cef_string_userfree_wide_t str );
These functions free the string structure allocated by the associated alloc function. Any string contents will first be cleared.

cef_string_utf16_clear

 CEF_EXPORT void cef_string_utf16_clear( cef_string_utf16_t* str );

cef_string_utf16_cmp

 CEF_EXPORT int cef_string_utf16_cmp( const cef_string_utf16_t* str1, const cef_string_utf16_t* str2 );

cef_string_utf16_set

 CEF_EXPORT int cef_string_utf16_set( const char16* src, size_t src_len, cef_string_utf16_t* output, int copy );

cef_string_utf16_to_lower

 CEF_EXPORT int cef_string_utf16_to_lower( const char16* src, size_t src_len, cef_string_utf16_t* output );
These functions convert utf16 string case using the current ICU locale. This may change the length of the string in some cases.

cef_string_utf16_to_upper

 CEF_EXPORT int cef_string_utf16_to_upper( const char16* src, size_t src_len, cef_string_utf16_t* output );

cef_string_utf16_to_utf8

 CEF_EXPORT int cef_string_utf16_to_utf8( const char16* src, size_t src_len, cef_string_utf8_t* output );

cef_string_utf16_to_wide

 CEF_EXPORT int cef_string_utf16_to_wide( const char16* src, size_t src_len, cef_string_wide_t* output );

cef_string_utf8_clear

 CEF_EXPORT void cef_string_utf8_clear( cef_string_utf8_t* str );

cef_string_utf8_cmp

 CEF_EXPORT int cef_string_utf8_cmp( const cef_string_utf8_t* str1, const cef_string_utf8_t* str2 );

cef_string_utf8_set

 CEF_EXPORT int cef_string_utf8_set( const char* src, size_t src_len, cef_string_utf8_t* output, int copy );

cef_string_utf8_to_utf16

 CEF_EXPORT int cef_string_utf8_to_utf16( const char* src, size_t src_len, cef_string_utf16_t* output );

cef_string_utf8_to_wide

 CEF_EXPORT int cef_string_utf8_to_wide( const char* src, size_t src_len, cef_string_wide_t* output );

cef_string_wide_clear

 CEF_EXPORT void cef_string_wide_clear( cef_string_wide_t* str );
These functions clear string values. The structure itself is not freed.

cef_string_wide_cmp

 CEF_EXPORT int cef_string_wide_cmp( const cef_string_wide_t* str1, const cef_string_wide_t* str2 );
These functions compare two string values with the same results as strcmp().

cef_string_wide_set

 CEF_EXPORT int cef_string_wide_set( const wchar_t* src, size_t src_len, cef_string_wide_t* output, int copy );
These functions set string values. If |copy| is true (1) the value will be copied instead of referenced. It is up to the user to properly manage the lifespan of references.

cef_string_wide_to_utf16

 CEF_EXPORT int cef_string_wide_to_utf16( const wchar_t* src, size_t src_len, cef_string_utf16_t* output );

cef_string_wide_to_utf8

 CEF_EXPORT int cef_string_wide_to_utf8( const wchar_t* src, size_t src_len, cef_string_utf8_t* output );
These functions convert between UTF-8, -16, and -32 strings. They are potentially slow so unnecessary conversions should be avoided. The best possible result will always be written to |output| with the boolean return value indicating whether the conversion is 100% valid.

cef_time_delta

 CEF_EXPORT int cef_time_delta( const cef_time_t* cef_time1, const cef_time_t* cef_time2, long long* delta );
Retrieve the delta in milliseconds between two time values.

cef_time_from_doublet

 CEF_EXPORT int cef_time_from_doublet( double time, cef_time_t* cef_time );

cef_time_from_timet

 CEF_EXPORT int cef_time_from_timet( time_t time, cef_time_t* cef_time );

cef_time_now

 CEF_EXPORT int cef_time_now( cef_time_t* cef_time );
Retrieve the current system time.

cef_time_to_doublet

 CEF_EXPORT int cef_time_to_doublet( const cef_time_t* cef_time, double* time );
Converts cef_time_t to/from 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". Returns true (1) on success and false (0) on failure.

cef_time_to_timet

 CEF_EXPORT int cef_time_to_timet( const cef_time_t* cef_time, time_t* time );
Converts cef_time_t to/from time_t. Returns true (1) on success and false (0) on failure.

cef_trace_counter

 CEF_EXPORT void cef_trace_counter( const char* category, const char* name, const char* value1_name, uint64 value1_val, const char* value2_name, uint64 value2_val, int copy );

cef_trace_counter_id

 CEF_EXPORT void cef_trace_counter_id( const char* category, const char* name, uint64 id, const char* value1_name, uint64 value1_val, const char* value2_name, uint64 value2_val, int copy );

cef_trace_event_async_begin

 CEF_EXPORT void cef_trace_event_async_begin( const char* category, const char* name, uint64 id, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy );

cef_trace_event_async_end

 CEF_EXPORT void cef_trace_event_async_end( const char* category, const char* name, uint64 id, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy );

cef_trace_event_async_step_into

 CEF_EXPORT void cef_trace_event_async_step_into( const char* category, const char* name, uint64 id, uint64 step, const char* arg1_name, uint64 arg1_val, int copy );

cef_trace_event_async_step_past

 CEF_EXPORT void cef_trace_event_async_step_past( const char* category, const char* name, uint64 id, uint64 step, const char* arg1_name, uint64 arg1_val, int copy );

cef_trace_event_begin

 CEF_EXPORT void cef_trace_event_begin( const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy );

cef_trace_event_end

 CEF_EXPORT void cef_trace_event_end( const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy );

cef_trace_event_instant

 CEF_EXPORT void cef_trace_event_instant( const char* category, const char* name, const char* arg1_name, uint64 arg1_val, const char* arg2_name, uint64 arg2_val, int copy );

cef_unload_library

 int cef_unload_library();
Unload the CEF library that was previously loaded. Returns true (1) on success and false (0) on failure.

cef_version_info

 CEF_EXPORT int cef_version_info( int entry );

CefAddCrossOriginWhitelistEntry

 bool CefAddCrossOriginWhitelistEntry( const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains );
Add an entry to the cross-origin access whitelist. The same-origin policy restricts how scripts hosted from different origins (scheme + domain + port) can communicate. By default, scripts can only access resources with the same origin. Scripts hosted on the HTTP and HTTPS schemes (but no other schemes) can use the "Access-Control-Allow-Origin" header to allow cross-origin requests. For example, https://source.example.com can make XMLHttpRequest requests on http://target.example.com if the http://target.example.com request returns an "Access-Control-Allow-Origin: https://source.example.com" response header. Scripts in separate frames or iframes and hosted from the same protocol and domain suffix can execute cross-origin JavaScript if both pages set the document.domain value to the same domain suffix. For example, scheme://foo.example.com and scheme://bar.example.com can communicate using JavaScript if both domains set document.domain="example.com". This method is used to allow access to origins that would otherwise violate the same-origin policy. Scripts hosted underneath the fully qualified |source_origin| URL (like http://www.example.com) will be allowed access to all resources hosted on the specified |target_protocol| and |target_domain|. If |target_domain| is non-empty and |allow_target_subdomains| if false only exact domain matches will be allowed. If |target_domain| contains a top- level domain component (like "example.com") and |allow_target_subdomains| is true sub-domain matches will be allowed. If |target_domain| is empty and |allow_target_subdomains| if true all domains and IP addresses will be allowed. This method cannot be used to bypass the restrictions on local or display isolated schemes. See the comments on CefRegisterCustomScheme for more information. This function may be called on any thread. Returns false if |source_origin| is invalid or the whitelist cannot be accessed.

CefBase64Decode

 CefRefPtr< CefBinaryValue > CefBase64Decode( const CefString& data );
Decodes the base64 encoded string |data|. The returned value will be NULL if the decoding fails.

CefBase64Encode

 CefString CefBase64Encode( const void* data, size_t data_size );
Encodes |data| as a base64 string.

CefBeginTracing

 bool CefBeginTracing( const CefString& categories, CefRefPtr< CefCompletionCallback > callback );
Start tracing events on all processes. Tracing is initialized asynchronously and |callback| will be executed on the UI thread after initialization is complete. If CefBeginTracing was called previously, or if a CefEndTracingAsync call is pending, CefBeginTracing will fail and return false. |categories| is a comma-delimited list of category wildcards. A category can have an optional '-' prefix to make it an excluded category. Having both included and excluded categories in the same list is not supported. Example: "test_MyTest*" Example: "test_MyTest*,test_OtherStuff" Example: "-excluded_category1,-excluded_category2" This function must be called on the browser process UI thread.

CefClearCrossOriginWhitelist

 bool CefClearCrossOriginWhitelist();
Remove all entries from the cross-origin access whitelist. Returns false if the whitelist cannot be accessed.

CefClearSchemeHandlerFactories

 bool CefClearSchemeHandlerFactories();
Clear all scheme handler factories registered with the global request context. Returns false on error. This function may be called on any thread in the browser process. Using this function is equivalent to calling CefRequestContext::GetGlobalContext()->ClearSchemeHandlerFactories().

CefCrashReportingEnabled

 bool CefCrashReportingEnabled();
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. ".app/Contents/Resources"). File contents are as follows: # Comments start with a hash character and must be on their own line. [Config] ProductName= ProductVersion= AppName= ExternalHandler= BrowserCrashForwardingEnabled= ServerURL= RateLimitEnabled= MaxUploadsPerDay= MaxDatabaseSizeInMb= MaxDatabaseAgeInDays= [CrashKeys] my_key1= my_key2= 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 empty 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 CefSettings.user_data_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 CefSettings.browser_subprocess_path value will be used. On macOS the existing subprocess app bundle will be used. If "BrowserCrashForwardingEnabled" is set to true 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 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.

CefCreateClosureTask

 CefRefPtr< CefTask > CefCreateClosureTask( const base::Closure& closure );
Create a CefTask that wraps a base::Closure. Can be used in combination with CefTaskRunner.

CefCreateDirectory

 bool CefCreateDirectory( const CefString& full_path );
Creates a directory and all parent directories if they don't already exist. Returns true 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.

CefCreateNewTempDirectory

 bool CefCreateNewTempDirectory( const CefString& prefix, CefString& new_temp_path );
Creates a new directory. On Windows if |prefix| is provided the new directory name is in the format of "prefixyyyy". Returns true 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.

CefCreateTempDirectoryInDirectory

 bool CefCreateTempDirectoryInDirectory( const CefString& base_dir, const CefString& prefix, CefString& new_dir );
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 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.

CefCreateURL

 bool CefCreateURL( const CefURLParts& parts, CefString& url );
Creates a URL from the specified |parts|, which must contain a non-empty spec or a non-empty host and path (at a minimum), but not both. Returns false if |parts| isn't initialized as described.

CefCurrentlyOn

 bool CefCurrentlyOn( CefThreadId threadId );
Returns true if called on the specified thread. Equivalent to using CefTaskRunner::GetForThread(threadId)->BelongsToCurrentThread().

CefDeleteFile

 bool CefDeleteFile( const CefString& path, bool recursive );
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 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 on successful deletion or if |path| does not exist. Calling this function on the browser process UI or IO threads is not allowed.

CefDirectoryExists

 bool CefDirectoryExists( const CefString& path );
Returns true if the given path exists and is a directory. Calling this function on the browser process UI or IO threads is not allowed.

CefDoMessageLoopWork

 void CefDoMessageLoopWork();
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 CefRunMessageLoop() function or CefSettings.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 CefSettings.external_message_pump option when using this function so that CefBrowserProcessHandler::OnScheduleMessagePumpWork() callbacks can facilitate the scheduling process. This function should only be called on the main application thread and only if CefInitialize() is called with a CefSettings.multi_threaded_message_loop value of false. This function will not block.

CefEnableHighDPISupport

 void CefEnableHighDPISupport();
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.

CefEndTracing

 bool CefEndTracing( const CefString& tracing_file, CefRefPtr< CefEndTracingCallback > callback );
Stop tracing events on all processes. This function will fail and return false if a previous call to CefEndTracingAsync is already pending or if CefBeginTracing was not called. |tracing_file| is the path at which tracing data will be written and |callback| is the callback that will be executed once all processes have sent their trace data. If |tracing_file| is empty a new temporary file path will be used. If |callback| is empty no trace data will be written. This function must be called on the browser process UI thread.

CefExecuteJavaScriptWithUserGestureForTests

 void CefExecuteJavaScriptWithUserGestureForTests( CefRefPtr< CefFrame > frame, const CefString& javascript );
Execute JavaScript with a user gesture to trigger functionality like onbeforeunload handlers that will otherwise be blocked.

CefExecuteProcess

 int CefExecuteProcess( const CefMainArgs& args, CefRefPtr< CefApp > application, void* windows_sandbox_info );
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 CefSettings.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 empty. The |windows_sandbox_info| parameter is only used on Windows and may be NULL (see cef_sandbox_win.h for details).

CefFormatUrlForSecurityDisplay

 CefString CefFormatUrlForSecurityDisplay( const CefString& origin_url );
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.

CefGetExtensionsForMimeType

 void CefGetExtensionsForMimeType( const CefString& mime_type, std::vector< CefString >& extensions );
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.

CefGetMimeType

 CefString CefGetMimeType( const CefString& extension );
Returns the mime type for the specified file extension or an empty string if unknown.

CefGetPath

 bool CefGetPath( PathKey key, CefString& path );
Retrieve the path associated with the specified |key|. Returns true on success. Can be called on any thread in the browser process.

CefGetTempDirectory

 bool CefGetTempDirectory( CefString& temp_dir );
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).

CefInitialize

 bool CefInitialize( const CefMainArgs& args, const CefSettings& settings, CefRefPtr< CefApp > application, void* windows_sandbox_info );
This function should be called on the main application thread to initialize the CEF browser process. The |application| parameter may be empty. A return value of true indicates that it succeeded and false 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).

CefIsCertStatusError

 bool CefIsCertStatusError( cef_cert_status_t status );
Returns true if the certificate status has any error, major or minor.

CefIsCertStatusMinorError

 bool CefIsCertStatusMinorError( cef_cert_status_t status );
Returns true if the certificate status represents only minor errors (e.g. failure to verify certificate revocation).

CefIsWebPluginUnstable

 void CefIsWebPluginUnstable( const CefString& path, CefRefPtr< CefWebPluginUnstableCallback > callback );
Query if a plugin is unstable. Can be called on any thread in the browser process.

CefLaunchProcess

 bool CefLaunchProcess( CefRefPtr< CefCommandLine > command_line );
Launches the process specified via |command_line|. Returns true upon success. Must be called on the browser process TID_PROCESS_LAUNCHER thread. Unix-specific notes: - All file descriptors open in the parent process will be closed in the child process except for stdin, stdout, and stderr. - If the first argument on the command line does not contain a slash, PATH will be searched. (See man execvp.)

CefLoadCRLSetsFile

 void CefLoadCRLSetsFile( const CefString& path );
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.

CefNowFromSystemTraceTime

 int64 CefNowFromSystemTraceTime();
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.

CefParseJSON

 CefRefPtr< CefValue > CefParseJSON( const CefString& json_string, cef_json_parser_options_t options );
Parses the specified |json_string| and returns a dictionary or list representation. If JSON parsing fails this method returns NULL.

CefParseJSONAndReturnError

 CefRefPtr< CefValue > CefParseJSONAndReturnError( const CefString& json_string, cef_json_parser_options_t options, cef_json_parser_error_t& error_code_out, CefString& error_msg_out );
Parses the specified |json_string| and returns a dictionary or list representation. If JSON parsing fails this method returns NULL and populates |error_code_out| and |error_msg_out| with an error code and a formatted error message respectively.

CefParseURL

 bool CefParseURL( const CefString& url, CefURLParts& parts );
Parse the specified |url| into its component parts. Returns false if the URL is empty or invalid.

CefPostDelayedTask

 bool CefPostDelayedTask( CefThreadId threadId, const base::Closure& closure, int64 delay_ms );
Post a Closure for delayed execution on the specified thread.

CefPostDelayedTask

 bool CefPostDelayedTask( CefThreadId threadId, CefRefPtr< CefTask > task, int64 delay_ms );
Post a task for delayed execution on the specified thread. Equivalent to using CefTaskRunner::GetForThread(threadId)->PostDelayedTask(task, delay_ms).

CefPostTask

 bool CefPostTask( CefThreadId threadId, CefRefPtr< CefTask > task );
Post a task for execution on the specified thread. Equivalent to using CefTaskRunner::GetForThread(threadId)->PostTask(task).

CefPostTask

 bool CefPostTask( CefThreadId threadId, const base::Closure& closure );
Post a Closure for execution on the specified thread.

CefQuitMessageLoop

 void CefQuitMessageLoop();
Quit the CEF message loop that was started by calling CefRunMessageLoop(). This function should only be called on the main application thread and only if CefRunMessageLoop() was used.

CefRefreshWebPlugins

 void CefRefreshWebPlugins();
Cause the plugin list to refresh the next time it is accessed regardless of whether it has already been loaded. Can be called on any thread in the browser process.

CefRegisterExtension

 bool CefRegisterExtension( const CefString& extension_name, const CefString& javascript_code, CefRefPtr< CefV8Handler > handler );
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:
  // 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;
    };
  })();
Example usage in the page:
  // 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();

CefRegisterSchemeHandlerFactory

 bool CefRegisterSchemeHandlerFactory( const CefString& scheme_name, const CefString& domain_name, CefRefPtr< CefSchemeHandlerFactory > factory );
Register a scheme handler factory with the global request context. An empty |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 CefApp::OnRegisterCustomSchemes() method in all processes. This function may be called multiple times to change or remove the factory that matches the specified |scheme_name| and optional |domain_name|. Returns false if an error occurs. This function may be called on any thread in the browser process. Using this function is equivalent to calling CefRequestContext::GetGlobalContext()->RegisterSchemeHandlerFactory().

CefRegisterWebPluginCrash

 void CefRegisterWebPluginCrash( const CefString& path );
Register a plugin crash. Can be called on any thread in the browser process but will be executed on the IO thread.

CefRegisterWidevineCdm

 void CefRegisterWidevineCdm( const CefString& path, CefRefPtr< CefRegisterCdmCallback > callback );
Register the Widevine CDM plugin. The client application is responsible for downloading an appropriate platform-specific CDM binary distribution from Google, extracting the contents, and building the required directory structure on the local machine. The CefBrowserHost::StartDownload method and CefZipArchive class can be used to implement this functionality in CEF. Contact Google via https://www.widevine.com/contact.html for details on CDM download. |path| is a directory that must contain the following files: 1. manifest.json file from the CDM binary distribution (see below). 2. widevinecdm file from the CDM binary distribution (e.g. widevinecdm.dll on on Windows, libwidevinecdm.dylib on OS X, libwidevinecdm.so on Linux). If any of these files are missing or if the manifest file has incorrect contents the registration will fail and |callback| will receive a |result| value of CEF_CDM_REGISTRATION_ERROR_INCORRECT_CONTENTS. The manifest.json file must contain the following keys: A. "os": Supported OS (e.g. "mac", "win" or "linux"). B. "arch": Supported architecture (e.g. "ia32" or "x64"). C. "x-cdm-module-versions": Module API version (e.g. "4"). D. "x-cdm-interface-versions": Interface API version (e.g. "8"). E. "x-cdm-host-versions": Host API version (e.g. "8"). F. "version": CDM version (e.g. "1.4.8.903"). G. "x-cdm-codecs": List of supported codecs (e.g. "vp8,vp9.0,avc1"). A through E are used to verify compatibility with the current Chromium version. If the CDM is not compatible the registration will fail and |callback| will receive a |result| value of CEF_CDM_REGISTRATION_ERROR_INCOMPATIBLE. |callback| will be executed asynchronously once registration is complete. On Linux this function must be called before CefInitialize() and the registration cannot be changed during runtime. If registration is not supported at the time that CefRegisterWidevineCdm() is called then |callback| will receive a |result| value of CEF_CDM_REGISTRATION_ERROR_NOT_SUPPORTED.

CefRemoveCrossOriginWhitelistEntry

 bool CefRemoveCrossOriginWhitelistEntry( const CefString& source_origin, const CefString& target_protocol, const CefString& target_domain, bool allow_target_subdomains );
Remove an entry from the cross-origin access whitelist. Returns false if |source_origin| is invalid or the whitelist cannot be accessed.

CefRunMessageLoop

 void CefRunMessageLoop();
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 CefInitialize() is called with a CefSettings.multi_threaded_message_loop value of false. This function will block until a quit message is received by the system.

CefSetCrashKeyValue

 void CefSetCrashKeyValue( const CefString& key, const CefString& value );
Sets or clears a specific key-value pair from the crash metadata.

CefSetOSModalLoop

 void CefSetOSModalLoop( bool osModalLoop );
Set to true before calling Windows APIs like TrackPopupMenu that enter a modal message loop. Set to false after exiting the modal message loop.

CefShutdown

 void CefShutdown();
This function should be called on the main application thread to shut down the CEF browser process before the application exits.

CefUnregisterInternalWebPlugin

 void CefUnregisterInternalWebPlugin( const CefString& path );
Unregister an internal plugin. This may be undone the next time CefRefreshWebPlugins() is called. Can be called on any thread in the browser process.

CefURIDecode

 CefString CefURIDecode( const CefString& text, bool convert_to_utf8, cef_uri_unescape_rule_t unescape_rule );
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 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.

CefURIEncode

 CefString CefURIEncode( const CefString& text, bool use_plus );
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 spaces will change to "+". The result is basically the same as encodeURIComponent in Javacript.

CefVisitWebPluginInfo

 void CefVisitWebPluginInfo( CefRefPtr< CefWebPluginInfoVisitor > visitor );
Visit web plugin information. Can be called on any thread in the browser process.

CefWriteJSON

 CefString CefWriteJSON( CefRefPtr< CefValue > node, cef_json_writer_options_t options );
Generates a JSON string from the specified root |node| which should be a dictionary or list value. Returns an empty string on failure. This method requires exclusive access to |node| including any underlying data.

CefZipDirectory

 bool CefZipDirectory( const CefString& src_dir, const CefString& dest_file, bool include_hidden_files );
Writes the contents of |src_dir| into a zip archive at |dest_file|. If |include_hidden_files| is true files starting with "." will be included. Returns true on success. Calling this function on the browser process UI or IO threads is not allowed.

char

 template< typename T, size_t N > char(& ArraySizeHelper( const T(& array )[ N] ) )[ N];

make_scoped_ptr

 template< typename T > scoped_ptr< T > make_scoped_ptr( T* ptr );

make_scoped_refptr

 template< typename T > scoped_refptr< T > make_scoped_refptr( T* t );

operator!=

 inline bool operator!=( const CefPoint& a, const CefPoint& b );

operator!=

 template< class T, class D > bool operator!=( T* p1, const scoped_ptr< T, D >& p2 );

operator!=

 inline bool operator!=( const CefRect& a, const CefRect& b );

operator!=

 inline bool operator!=( const CefDraggableRegion& a, const CefDraggableRegion& b );

operator!=

 inline bool operator!=( const CefSize& a, const CefSize& b );

operator!=

 inline bool operator!=( const CefRange& a, const CefRange& b );

operator!=

 inline bool operator!=( const CefInsets& a, const CefInsets& b );

operator<<

 std::ostream& operator<<( std::ostream& out, const wchar_t* wstr );

operator<<

 inline std::ostream& operator<<( std::ostream& out, const std::wstring& wstr );

operator==

 inline bool operator==( const CefDraggableRegion& a, const CefDraggableRegion& b );

operator==

 inline bool operator==( const CefRange& a, const CefRange& b );

operator==

 inline bool operator==( const CefInsets& a, const CefInsets& b );

operator==

 inline bool operator==( const CefSize& a, const CefSize& b );

operator==

 inline bool operator==( const CefRect& a, const CefRect& b );

operator==

 inline bool operator==( const CefPoint& a, const CefPoint& b );

operator==

 template< class T, class D > bool operator==( T* p1, const scoped_ptr< T, D >& p2 );

swap

 template< class T, class D > void swap( scoped_ptr< T, D >& p1, scoped_ptr< T, D >& p2 );

 Overview   Project   Class   Tree   Index 
CEF3 C++ API Docs - Version 75.1.4+g4210896+chromium-75.0.3770.100
FRAMES    NO FRAMES
SUMMARY:  INNER | FIELD | CONSTR | METHOD

Chromium Embedded Framework (CEF) Copyright © 2016 Marshall A. Greenblatt