初识CEF

1 #define REQUIRE_UI_THREAD()   ASSERT(CefCurrentlyOn(TID_UI));
2 #define REQUIRE_IO_THREAD()   ASSERT(CefCurrentlyOn(TID_IO));
3 #define REQUIRE_FILE_THREAD() ASSERT(CefCurrentlyOn(TID_FILE));

 1 class MyClass : public CefBase {
 2  public:
 3   // Various class methods here...
 4 
 5  private:
 6   // Various class members here...
 7 
 8   IMPLEMENT_REFCOUNTING(MyClass);  // Provides atomic refcounting implementation.
 9 };
10 
11 // References a MyClass instance
12 CefRefPtr<MyClass> my_class = new MyClass();

1 typedef struct _cef_string_utf16_t {
2   char16* str;  // Pointer to the string
3   size_t length;  // String length
4   void (*dtor)(char16* str);  // Destructor for freeing the string on the correct heap
5 } cef_string_utf16_t;

1 typedef char16 cef_char_t;
2 typedef cef_string_utf16_t cef_string_t;

 1 std::string str = “Some UTF8 string”;
 2 
 3 // Equivalent ways of assigning |str| to |cef_str|. Conversion from UTF8 will occur if necessary.
 4 CefString cef_str(str);
 5 cef_str = str;
 6 cef_str.FromString(str);
 7 
 8 // Equivalent ways of assigning |cef_str| to |str|. Conversion to UTF8 will occur if necessary.
 9 str = cef_str;
10 str = cef_str.ToString();

 1 std::wstring str = “Some wide string”;
 2 
 3 // Equivalent ways of assigning |str| to |cef_str|. Conversion from wide will occur if necessary.
 4 CefString cef_str(str);
 5 cef_str = str;
 6 cef_str.FromWString(str);
 7 
 8 // Equivalent ways of assigning |cef_str| to |str|. Conversion to wide will occur if necessary.
 9 str = cef_str;
10 str = cef_str.ToWString();

1 const char* cstr = “Some ASCII string”;
2 CefString cef_str;
3 cef_str.FromASCII(cstr);

1 CefSettings settings;
2 const char* path = “/path/to/log.txt”;
3 
4 // Equivalent assignments.
5 CefString(&settings.log_file).FromASCII(path);
6 cef_string_from_ascii(path, strlen(path), &settings.log_file);

1 Application/
2     cefclient.exe  <= cefclient application executable 
3     libcef.dll <= main CEF library 
4     icudt.dll <= ICU unicode support library 
5     ffmpegsumo.dll <= HTML5 audio/video support library 
6     libEGL.dll, libGLESv2.dll, … <= accelerated compositing support libraries 
7     cef.pak, devtools_resources.pak <= non-localized resources and strings 
8     locales/
9         en-US.pak, … <= locale-specific resources and strings

1 Application/
2     cefclient  <= cefclient application executable 
3     libcef.so <= main CEF library 
4     ffmpegsumo.so <-- HTML5 audio/video support library 
5     cef.pak, devtools_resources.pak <= non-localized resources and strings 
6     locales/
7         en-US.pak, … <= locale-specific resources and strings 
8     files/
9         binding.html, … <= cefclient application resources 

 1 cefclient.app/
 2     Contents/
 3         Frameworks/
 4             Chromium Embedded Framework.framework/
 5                 Libraries/
 6                     ffmpegsumo.so <= HTML5 audio/video support library 
 7                     libcef.dylib <= main CEF library
 8                 Resources/
 9                     cef.pak, devtools_resources.pak <= non-localized resources and strings
10                     *.png, *.tiff <= Blink image and cursor resources 
11                     en.lproj/, … <= locale-specific resources and strings 
12             libplugin_carbon_interpose.dylib <= plugin support library
13             cefclient Helper.app/
14                 Contents/
15                     Info.plist
16                     MacOS/
17                         cefclient Helper <= helper executable 
18                     Pkginfo
19             cefclient Helper EH.app/
20                 Contents/
21                     Info.plist
22                     MacOS/
23                         cefclient Helper EH <= helper executable 
24                     Pkginfo
25             cefclient Helper NP.app/
26                 Contents/
27                     Info.plist
28                     MacOS/
29                         cefclient Helper NP <= helper executable 
30                     Pkginfo
31         Info.plist
32         MacOS/
33             cefclient <= cefclient application executable 
34         Pkginfo
35         Resources/
36             binding.html, … <= cefclient application resources 

CefMainArgs main_args(argc, argv);

CefMainArgs main_args(hInstance);

 1 int main(int argc, char* argv[]) {
 2   // Structure for passing command-line arguments.
 3   // The definition of this structure is platform-specific.
 4   CefMainArgs main_args(argc, argv);
 5 
 6   // Optional implementation of the CefApp interface.
 7   CefRefPtr<MyApp> app(new MyApp);
 8 
 9   // Execute the sub-process logic, if any. This will either return immediately for the browser
10   // process or block until the sub-process should exit.
11   int exit_code = CefExecuteProcess(main_args, app.get());
12   if (exit_code >= 0) {
13     // The sub-process terminated, exit now.
14     return exit_code;
15   }
16 
17   // Populate this structure to customize CEF behavior.
18   CefSettings settings;
19 
20   // Initialize CEF in the main process.
21   CefInitialize(main_args, settings, app.get());
22 
23   // Run the CEF message loop. This will block until CefQuitMessageLoop() is called.
24   CefRunMessageLoop();
25 
26   // Shut down CEF.
27   CefShutdown();
28 
29   return 0;
30 }

 1 // Program entry-point function.
 2 // 程序入口函数
 3 int main(int argc, char* argv[]) {
 4   // Structure for passing command-line arguments.
 5   // The definition of this structure is platform-specific.
 6   // 传递命令行参数的结构体。
 7   // 这个结构体的定义与平台相关。
 8   CefMainArgs main_args(argc, argv);
 9 
10   // Optional implementation of the CefApp interface.
11   // 可选择性地实现CefApp接口
12   CefRefPtr<MyApp> app(new MyApp);
13 
14   // Populate this structure to customize CEF behavior.
15   // 填充这个结构体，用于定制CEF的行为。
16   CefSettings settings;
17 
18   // Specify the path for the sub-process executable.
19   // 指定子进程的执行路径
20   CefString(&settings.browser_subprocess_path).FromASCII(“/path/to/subprocess”);
21 
22   // Initialize CEF in the main process.
23   // 在主进程中初始化CEF 
24   CefInitialize(main_args, settings, app.get());
25 
26   // Run the CEF message loop. This will block until CefQuitMessageLoop() is called.
27   // 执行消息循环，此时会堵塞，直到CefQuitMessageLoop()函数被调用。
28   CefRunMessageLoop();
29 
30   // Shut down CEF.
31   // 关闭CEF
32   CefShutdown();
33 
34   return 0;
35 }

 1 // Program entry-point function.
 2 // 程序入口函数
 3 int main(int argc, char* argv[]) {
 4   // Structure for passing command-line arguments.
 5   // The definition of this structure is platform-specific.
 6   // 传递命令行参数的结构体。
 7   // 这个结构体的定义与平台相关。
 8   CefMainArgs main_args(argc, argv);
 9 
10   // Optional implementation of the CefApp interface.
11   // 可选择性地实现CefApp接口
12   CefRefPtr<MyApp> app(new MyApp);
13 
14   // Execute the sub-process logic. This will block until the sub-process should exit.
15   // 执行子进程逻辑，此时会堵塞直到子进程退出。
16   return CefExecuteProcess(main_args, app.get());
17 }

browser->GetMainFrame()->LoadURL(some_url);

browser->GoBack();

 1 // Implementation of the CefStringVisitor interface.
 2 class Visitor : public CefStringVisitor {
 3  public:
 4   Visitor() {}
 5 
 6   // Called asynchronously when the HTML contents are available.
 7   virtual void Visit(const CefString& string) OVERRIDE {
 8     // Do something with |string|...
 9   }
10 
11   IMPLEMENT_REFCOUNTING(Visitor);
12 };
13 
14 browser->GetMainFrame()->GetSource(new Visitor());

// CefWindowHandle is defined as HWND on Windows, NSView* on Mac OS X
// and GtkWidget* on Linux.
CefWindowHandle window_handle = browser->GetHost()->GetWindowHandle();

 1 // MyApp implements CefApp and the process-specific interfaces.
 2 class MyApp : public CefApp,
 3               public CefBrowserProcessHandler,
 4               public CefRenderProcessHandler {
 5  public:
 6   MyApp() {}
 7 
 8   // CefApp methods. Important to return |this| for the handler callbacks.
 9   virtual void OnBeforeCommandLineProcessing(
10       const CefString& process_type,
11       CefRefPtr<CefCommandLine> command_line) {
12     // Programmatically configure command-line arguments...
13   }
14   virtual void OnRegisterCustomSchemes(
15       CefRefPtr<CefSchemeRegistrar> registrar) OVERRIDE {
16     // Register custom schemes...
17   }
18   virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
19       OVERRIDE { return this; }
20   virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler()
21       OVERRIDE { return this; }
22 
23   // CefBrowserProcessHandler methods.
24   virtual void OnContextInitialized() OVERRIDE {
25     // The browser process UI thread has been initialized...
26   }
27   virtual void OnRenderProcessThreadCreated(CefRefPtr<CefListValue> extra_info)
28                                             OVERRIDE {
29     // Send startup information to a new render process...
30   }
31 
32   // CefRenderProcessHandler methods.
33   virtual void OnRenderThreadCreated(CefRefPtr<CefListValue> extra_info)
34                                      OVERRIDE {
35     // The render process main thread has been initialized...
36     // Receive startup information in the new render process...
37   }
38   virtual void OnWebKitInitialized(CefRefPtr<ClientApp> app) OVERRIDE {
39     // WebKit has been initialized, register V8 extensions...
40   }
41   virtual void OnBrowserCreated(CefRefPtr<CefBrowser> browser) OVERRIDE {
42     // Browser created in this render process...
43   }
44   virtual void OnBrowserDestroyed(CefRefPtr<CefBrowser> browser) OVERRIDE {
45     // Browser destroyed in this render process...
46   }
47   virtual bool OnBeforeNavigation(CefRefPtr<CefBrowser> browser,
48                                   CefRefPtr<CefFrame> frame,
49                                   CefRefPtr<CefRequest> request,
50                                   NavigationType navigation_type,
51                                   bool is_redirect) OVERRIDE {
52     // Allow or block different types of navigation...
53   }
54   virtual void OnContextCreated(CefRefPtr<CefBrowser> browser,
55                                 CefRefPtr<CefFrame> frame,
56                                 CefRefPtr<CefV8Context> context) OVERRIDE {
57     // JavaScript context created, add V8 bindings here...
58   }
59   virtual void OnContextReleased(CefRefPtr<CefBrowser> browser,
60                                  CefRefPtr<CefFrame> frame,
61                                  CefRefPtr<CefV8Context> context) OVERRIDE {
62     // JavaScript context released, release V8 references here...
63   }
64   virtual bool OnProcessMessageReceived(
65       CefRefPtr<CefBrowser> browser,
66       CefProcessId source_process,
67       CefRefPtr<CefProcessMessage> message) OVERRIDE {
68     // Handle IPC messages from the browser process...
69   }
70 
71   IMPLEMENT_REFCOUNTING(MyApp);
72 };

  1 // MyHandler implements CefClient and a number of other interfaces.
  2 class MyHandler : public CefClient,
  3                   public CefContextMenuHandler,
  4                   public CefDisplayHandler,
  5                   public CefDownloadHandler,
  6                   public CefDragHandler,
  7                   public CefGeolocationHandler,
  8                   public CefKeyboardHandler,
  9                   public CefLifeSpanHandler,
 10                   public CefLoadHandler,
 11                   public CefRequestHandler {
 12  public:
 13   MyHandler();
 14 
 15   // CefClient methods. Important to return |this| for the handler callbacks.
 16   virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() OVERRIDE {
 17     return this;
 18   }
 19   virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE {
 20     return this;
 21   }
 22   virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() OVERRIDE {
 23     return this;
 24   }
 25   virtual CefRefPtr<CefDragHandler> GetDragHandler() OVERRIDE {
 26     return this;
 27   }
 28   virtual CefRefPtr<CefGeolocationHandler> GetGeolocationHandler() OVERRIDE {
 29     return this;
 30   }
 31   virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() OVERRIDE {
 32     return this;
 33   }
 34   virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE {
 35     return this;
 36   }
 37   virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE {
 38     return this;
 39   }
 40   virtual CefRefPtr<CefRequestHandler> GetRequestHandler() OVERRIDE {
 41     return this;
 42   }
 43   virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
 44                                         CefProcessId source_process,
 45                                         CefRefPtr<CefProcessMessage> message)
 46                                         OVERRIDE {
 47     // Handle IPC messages from the render process...
 48   }
 49 
 50   // CefContextMenuHandler methods
 51   virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
 52                                    CefRefPtr<CefFrame> frame,
 53                                    CefRefPtr<CefContextMenuParams> params,
 54                                    CefRefPtr<CefMenuModel> model) OVERRIDE {
 55     // Customize the context menu...
 56   }
 57   virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
 58                                     CefRefPtr<CefFrame> frame,
 59                                     CefRefPtr<CefContextMenuParams> params,
 60                                     int command_id,
 61                                     EventFlags event_flags) OVERRIDE {
 62     // Handle a context menu command...
 63   }
 64 
 65   // CefDisplayHandler methods
 66   virtual void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
 67                                     bool isLoading,
 68                                     bool canGoBack,
 69                                     bool canGoForward) OVERRIDE {
 70     // Update UI for browser state...
 71   }
 72   virtual void OnAddressChange(CefRefPtr<CefBrowser> browser,
 73                                CefRefPtr<CefFrame> frame,
 74                                const CefString& url) OVERRIDE {
 75     // Update the URL in the address bar...
 76   }
 77   virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,
 78                              const CefString& title) OVERRIDE {
 79     // Update the browser window title...
 80   }
 81   virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
 82                                 const CefString& message,
 83                                 const CefString& source,
 84                                 int line) OVERRIDE {
 85     // Log a console message...
 86   }
 87 
 88   // CefDownloadHandler methods
 89   virtual void OnBeforeDownload(
 90       CefRefPtr<CefBrowser> browser,
 91       CefRefPtr<CefDownloadItem> download_item,
 92       const CefString& suggested_name,
 93       CefRefPtr<CefBeforeDownloadCallback> callback) OVERRIDE {
 94     // Specify a file path or cancel the download...
 95   }
 96   virtual void OnDownloadUpdated(
 97       CefRefPtr<CefBrowser> browser,
 98       CefRefPtr<CefDownloadItem> download_item,
 99       CefRefPtr<CefDownloadItemCallback> callback) OVERRIDE {
100     // Update the download status...
101   }
102 
103   // CefDragHandler methods
104   virtual bool OnDragEnter(CefRefPtr<CefBrowser> browser,
105                            CefRefPtr<CefDragData> dragData,
106                            DragOperationsMask mask) OVERRIDE {
107     // Allow or deny drag events...
108   }
109 
110   // CefGeolocationHandler methods
111   virtual void OnRequestGeolocationPermission(
112       CefRefPtr<CefBrowser> browser,
113       const CefString& requesting_url,
114       int request_id,
115       CefRefPtr<CefGeolocationCallback> callback) OVERRIDE {
116     // Allow or deny geolocation API access...
117   }
118 
119   // CefKeyboardHandler methods
120   virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
121                              const CefKeyEvent& event,
122                              CefEventHandle os_event,
123                              bool* is_keyboard_shortcut) OVERRIDE {
124     // Perform custom handling of key events...
125   }
126 
127   // CefLifeSpanHandler methods
128   virtual bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
129                              CefRefPtr<CefFrame> frame,
130                              const CefString& target_url,
131                              const CefString& target_frame_name,
132                              const CefPopupFeatures& popupFeatures,
133                              CefWindowInfo& windowInfo,
134                              CefRefPtr<CefClient>& client,
135                              CefBrowserSettings& settings,
136                              bool* no_javascript_access) OVERRIDE {
137     // Allow or block popup windows, customize popup window creation...
138   }
139   virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE {
140     // Browser window created successfully...
141   }
142   virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE {
143     // Allow or block browser window close...
144   }
145   virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE {
146     // Browser window is closed, perform cleanup...
147   }
148 
149   // CefLoadHandler methods
150   virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,
151                            CefRefPtr<CefFrame> frame) OVERRIDE {
152     // A frame has started loading content...
153   }
154   virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
155                          CefRefPtr<CefFrame> frame,
156                          int httpStatusCode) OVERRIDE {
157     // A frame has finished loading content...
158   }
159   virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
160                            CefRefPtr<CefFrame> frame,
161                            ErrorCode errorCode,
162                            const CefString& errorText,
163                            const CefString& failedUrl) OVERRIDE {
164     // A frame has failed to load content...
165   }
166   virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
167                                          TerminationStatus status) OVERRIDE {
168     // A render process has crashed...
169   }
170 
171   // CefRequestHandler methods
172   virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
173       CefRefPtr<CefBrowser> browser,
174       CefRefPtr<CefFrame> frame,
175       CefRefPtr<CefRequest> request) OVERRIDE {
176     // Optionally intercept resource requests...
177   }
178   virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,
179                               const CefString& origin_url,
180                               int64 new_size,
181                               CefRefPtr<CefQuotaCallback> callback) OVERRIDE {
182     // Allow or block quota requests...
183   }
184   virtual void OnProtocolExecution(CefRefPtr<CefBrowser> browser,
185                                    const CefString& url,
186                                    bool& allow_os_execution) OVERRIDE {
187     // Handle execution of external protocols...
188   }
189 
190   IMPLEMENT_REFCOUNTING(MyHandler);
191 };

// Information about the window that will be created including parenting, size, etc.
// The definition of this structure is platform-specific.

 1 // 定义的结构体与平台相关
 2 
 3 CefWindowInfo info;
 4 // On Windows for example...
 5 info.SetAsChild(parent_hwnd, client_rect);
 6 
 7 // Customize this structure to control browser behavior.
 8 CefBrowserSettings settings;
 9 
10 // CefClient implementation.
11 CefRefPtr<MyClient> client(new MyClient);
12 
13 // Create the browser asynchronously. Initially loads the Google URL.
14 CefBrowserHost::CreateBrowser(info, client.get(), “http://www.google.com”, settings);
15 
16 The CefLifeSpanHandler class provides the callbacks necessary for managing browser life span. Below is an extract of the relevant methods and members.
17 
18 CefLifeSpanHandler 类提供管理 Browser生命周期必需的回调。以下为相关方法和成员。
19 
20 class MyClient : public CefClient,
21                  public CefLifeSpanHandler,
22                  ... {
23   // CefClient methods.
24   virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE {
25     return this;
26   }
27 
28   // CefLifeSpanHandler methods.
29   void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
30   bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
31   void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
32 
33   // Member accessors.
34   CefRefPtr<CefBrowser> GetBrower() { return m_Browser; }
35   bool IsClosing() { return m_bIsClosing; }
36 
37  private:
38   CefRefPtr<CefBrowser> m_Browser;
39   int m_BrowserId;
40   int m_BrowserCount;
41   bool m_bIsClosing;
42 
43   IMPLEMENT_REFCOUNTING(MyHandler);
44   IMPLEMENT_LOCKING(MyHandler);
45 };

 1 void MyClient::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
 2   // Must be executed on the UI thread.
 3   REQUIRE_UI_THREAD();
 4   // Protect data members from access on multiple threads.
 5   AutoLock lock_scope(this);
 6 
 7   if (!m_Browser.get())   {
 8     // Keep a reference to the main browser.
 9     m_Browser = browser;
10     m_BrowserId = browser->GetIdentifier();
11   }
12 
13   // Keep track of how many browsers currently exist.
14   m_BrowserCount++;
15 }

// Notify the browser window that we would like to close it. This will result in a call to 
// MyHandler::DoClose() if the JavaScript ‘onbeforeunload‘ event handler allows it.
browser->GetHost()->CloseBrowser(false);

 1 case WM_CLOSE:
 2   if (g_handler.get() && !g_handler->IsClosing()) {
 3     CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
 4     if (browser.get()) {
 5       // Notify the browser window that we would like to close it. This will result in a call to 
 6       // MyHandler::DoClose() if the JavaScript ‘onbeforeunload‘ event handler allows it.
 7       browser->GetHost()->CloseBrowser(false);
 8 
 9       // Cancel the close.
10       return 0;
11     }
12   }
13 
14   // Allow the close.
15   break;
16 
17 case WM_DESTROY:
18   // Quitting CEF is handled in MyHandler::OnBeforeClose().
19   return 0;
20 }

 1 gboolean delete_event(GtkWidget* widget, GdkEvent* event,
 2                       GtkWindow* window) {
 3   if (g_handler.get() && !g_handler->IsClosing()) {
 4     CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
 5     if (browser.get()) {
 6       // Notify the browser window that we would like to close it. This will result in a call to 
 7       // MyHandler::DoClose() if the JavaScript ‘onbeforeunload‘ event handler allows it.
 8       browser->GetHost()->CloseBrowser(false);
 9 
10       // Cancel the close.
11       return TRUE;
12     }
13   }
14 
15   // Allow the close.
16   return FALSE;
17 }

 1 // Called when the window is about to close. Perform the self-destruction
 2 // sequence by getting rid of the window. By returning YES, we allow the window
 3 // to be removed from the screen.
 4 - (BOOL)windowShouldClose:(id)window {
 5   if (g_handler.get() && !g_handler->IsClosing()) {
 6     CefRefPtr<CefBrowser> browser = g_handler->GetBrowser();
 7     if (browser.get()) {
 8       // Notify the browser window that we would like to close it. This will result in a call to 
 9       // MyHandler::DoClose() if the JavaScript ‘onbeforeunload‘ event handler allows it.
10       browser->GetHost()->CloseBrowser(false);
11 
12       // Cancel the close.
13       return NO;
14     }
15   }
16 
17   // Try to make the window go away.
18   [window autorelease];
19 
20   // Clean ourselves up after clearing the stack of anything that might have the
21   // window on it.
22   [self performSelectorOnMainThread:@selector(cleanup:)
23                          withObject:window
24                       waitUntilDone:NO];
25 
26   // Allow the close.
27   return YES;
28 }

 1 bool MyClient::DoClose(CefRefPtr<CefBrowser> browser) {
 2   // Must be executed on the UI thread.
 3   REQUIRE_UI_THREAD();
 4   // Protect data members from access on multiple threads.
 5   AutoLock lock_scope(this);
 6 
 7   // Closing the main window requires special handling. See the DoClose()
 8   // documentation in the CEF header for a detailed description of this
 9   // process.
10   if (m_BrowserId == browser->GetIdentifier()) {
11     // Notify the browser that the parent window is about to close.
12     browser->GetHost()->ParentWindowWillClose();
13 
14     // Set a flag to indicate that the window close should be allowed.
15     m_bIsClosing = true;
16   }
17 
18   // Allow the close. For windowed browsers this will result in the OS close
19   // event being sent.
20   return false;
21 }

 1 void MyHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
 2   // Must be executed on the UI thread.
 3   REQUIRE_UI_THREAD();
 4   // Protect data members from access on multiple threads.
 5   AutoLock lock_scope(this);
 6 
 7   if (m_BrowserId == browser->GetIdentifier()) {
 8     // Free the browser pointer so that the browser can be destroyed.
 9     m_Browser = NULL;
10   }
11 
12   if (--m_BrowserCount == 0) {
13     // All browser windows have closed. Quit the application message loop.
14     CefQuitMessageLoop();
15   }
16 }

CefPostTask(TID_UI, NewCefRunnableMethod(object, &MyObject::MyMethod, param1, param2));

CefPostTask(TID_IO, NewCefRunnableFunction(MyFunction, param1, param2));

CefRefPtr<CefTaskRunner> task_runner = CefTaskRunner::GetForThread(TID_UI);

// Create the message object.
CefRefPtr<CefProcessMessage> msg= CefProcessMessage::Create(“my_message”);

// Retrieve the argument list object.
CefRefPtr<CefListValue> args = msg>GetArgumentList();

// Populate the argument values.
args->SetString(0, “my string”);
args->SetInt(0, 10);

// Send the process message to the render process.
// Use PID_BROWSER instead when sending a message to the browser process.
browser->SendProcessMessage(PID_RENDERER, msg);

bool MyHandler::OnProcessMessageReceived(
    CefRefPtr<CefBrowser> browser,
    CefProcessId source_process,
    CefRefPtr<CefProcessMessage> message) {
  // Check the message name.
  const std::string& message_name = message->GetName();
  if (message_name == “my_message”) {
    // Handle the message here...
    return true;
  }
  return false;
}

// Helper macros for splitting and combining the int64 frame ID value.
#define MAKE_INT64(int_low, int_high) \
    ((int64) (((int) (int_low)) | ((int64) ((int) (int_high))) << 32))
#define LOW_INT(int64_val) ((int) (int64_val))
#define HIGH_INT(int64_val) ((int) (((int64) (int64_val) >> 32) & 0xFFFFFFFFL))

// Sending the frame ID.
const int64 frame_id = frame->GetIdentifier();
args->SetInt(0, LOW_INT(frame_id));
args->SetInt(1, HIGH_INT(frame_id));

// Receiving the frame ID.
const int64 frame_id = MAKE_INT64(args->GetInt(0), args->GetInt(1));
CefRefPtr<CefFrame> frame = browser->GetFrame(frame_id);

// Create and send a new query.
var request_id = window.cefQuery({
    request: ‘my_request‘,
    persistent: false,
    onSuccess: function(response) {},
    onFailure: function(error_code, error_message) {}
});

// Optionally cancel the query.
window.cefQueryCancel(request_id);

 1 class Callback : public CefBase {
 2  public:
 3   ///
 4   // Notify the associated JavaScript onSuccess callback that the query has
 5   // completed successfully with the specified |response|.
 6   ///
 7   virtual void Success(const CefString& response) =0;
 8 
 9   ///
10   // Notify the associated JavaScript onFailure callback that the query has
11   // failed with the specified |error_code| and |error_message|.
12   ///
13   virtual void Failure(int error_code, const CefString& error_message) =0;
14 };
15 
16 class Handler {
17  public:
18   ///
19   // Executed when a new query is received. |query_id| uniquely identifies the
20   // query for the life span of the router. Return true to handle the query
21   // or false to propagate the query to other registered handlers, if any. If
22   // no handlers return true from this method then the query will be
23   // automatically canceled with an error code of -1 delivered to the
24   // JavaScript onFailure callback. If this method returns true then a
25   // Callback method must be executed either in this method or asynchronously
26   // to complete the query.
27   ///
28   virtual bool OnQuery(CefRefPtr<CefBrowser> browser,
29                        CefRefPtr<CefFrame> frame,
30                        int64 query_id,
31                        const CefString& request,
32                        bool persistent,
33                        CefRefPtr<Callback> callback) {
34     return false;
35   }
36 
37   ///
38   // Executed when a query has been canceled either explicitly using the
39   // JavaScript cancel function or implicitly due to browser destruction,
40   // navigation or renderer process termination. It will only be called for
41   // the single handler that returned true from OnQuery for the same
42   // |query_id|. No references to the associated Callback object should be
43   // kept after this method is called, nor should any Callback methods be
44   // executed.
45   ///
46   virtual void OnQueryCanceled(CefRefPtr<CefBrowser> browser,
47                                CefRefPtr<CefFrame> frame,
48                                int64 query_id) {}
49 };

// In JavaScript register the callback function.
app.setMessageCallback(‘binding_test‘, function(name, args) {
  document.getElementById(‘result‘).value = "Response: "+args[0];
});

// Map of message callbacks.
typedef std::map<std::pair<std::string, int>,
                 std::pair<CefRefPtr<CefV8Context>, CefRefPtr<CefV8Value> > >
                 CallbackMap;
CallbackMap callback_map_;

// In the CefV8Handler::Execute implementation for “setMessageCallback”.
if (arguments.size() == 2 && arguments[0]->IsString() &&
    arguments[1]->IsFunction()) {
  std::string message_name = arguments[0]->GetStringValue();
  CefRefPtr<CefV8Context> context = CefV8Context::GetCurrentContext();
  int browser_id = context->GetBrowser()->GetIdentifier();
  callback_map_.insert(
      std::make_pair(std::make_pair(message_name, browser_id),
                     std::make_pair(context, arguments[1])));
}

// Execute the registered JavaScript callback if any.
if (!callback_map_.empty()) {
  const CefString& message_name = message->GetName();
  CallbackMap::const_iterator it = callback_map_.find(
      std::make_pair(message_name.ToString(),
                     browser->GetIdentifier()));
  if (it != callback_map_.end()) {
    // Keep a local reference to the objects. The callback may remove itself
    // from the callback map.
    CefRefPtr<CefV8Context> context = it->second.first;
    CefRefPtr<CefV8Value> callback = it->second.second;

    // Enter the context.
    context->Enter();

    CefV8ValueList arguments;

    // First argument is the message name.
    arguments.push_back(CefV8Value::CreateString(message_name));

    // Second argument is the list of message arguments.
    CefRefPtr<CefListValue> list = message->GetArgumentList();
    CefRefPtr<CefV8Value> args = CefV8Value::CreateArray(list->GetSize());
    SetList(list, args);  // Helper function to convert CefListValue to CefV8Value.
    arguments.push_back(args);

    // Execute the callback.
    CefRefPtr<CefV8Value> retval = callback->ExecuteFunction(NULL, arguments);
    if (retval.get()) {
      if (retval->IsBool())
        handled = retval->GetBoolValue();
    }

    // Exit the context.
    context->Exit();
  }
}

void MyHandler::OnContextReleased(CefRefPtr<CefBrowser> browser,
                                  CefRefPtr<CefFrame> frame,
                                  CefRefPtr<CefV8Context> context) {
  // Remove any JavaScript callbacks registered for the context that has been released.
  if (!callback_map_.empty()) {
    CallbackMap::iterator it = callback_map_.begin();
    for (; it != callback_map_.end();) {
      if (it->second.first->IsSame(context))
        callback_map_.erase(it++);
      else
        ++it;
    }
  }
}

browser->GetMainFrame()->LoadURL(some_url);

// Create a CefRequest object.
CefRefPtr<CefRequest> request = CefRequest::Create();

// Set the request URL.
request->SetURL(some_url);

// Set the request method. Supported methods include GET, POST, HEAD, DELETE and PUT.
request->SetMethod(“POST”);

// Optionally specify custom headers.
CefRequest::HeaderMap headerMap;
headerMap.insert(
    std::make_pair("X-My-Header", "My Header Value"));
request->SetHeaderMap(headerMap);

// Optionally specify upload content.
// The default “Content-Type” header value is "application/x-www-form-urlencoded".
// Set “Content-Type” via the HeaderMap if a different value is desired.
const std::string& upload_data = “arg1=val1&arg2=val2”;
CefRefPtr<CefPostData> postData = CefPostData::Create();
CefRefPtr<CefPostDataElement> element = CefPostDataElement::Create();
element->SetToBytes(upload_data.size(), upload_data.c_str());
postData->AddElement(element);
request->SetPostData(postData);

class MyRequestClient : public CefURLRequestClient {
 public:
  MyRequestClient()
    : upload_total_(0),
      download_total_(0) {}

  virtual void OnRequestComplete(CefRefPtr<CefURLRequest> request) OVERRIDE {
    CefURLRequest::Status status = request->GetRequestStatus();
    CefURLRequest::ErrorCode error_code = request->GetRequestError();
    CefRefPtr<CefResponse> response = request->GetResponse();

    // Do something with the response...
  }

  virtual void OnUploadProgress(CefRefPtr<CefURLRequest> request,
                                uint64 current,
                                uint64 total) OVERRIDE {
    upload_total_ = total;
  }

  virtual void OnDownloadProgress(CefRefPtr<CefURLRequest> request,
                                  uint64 current,
                                  uint64 total) OVERRIDE {
    download_total_ = total;
  }

  virtual void OnDownloadData(CefRefPtr<CefURLRequest> request,
                              const void* data,
                              size_t data_length) OVERRIDE {
    download_data_ += std::string(static_cast<const char*>(data), data_length);
  }

 private:
  uint64 upload_total_;
  uint64 download_total_;
  std::string download_data_;

 private:
  IMPLEMENT_REFCOUNTING(MyRequestClient);
};

// Set up the CefRequest object.
CefRefPtr<CefRequest> request = CefRequest::Create();
// Populate |request| as shown above...

// Create the client instance.
CefRefPtr<MyRequestClient> client = new MyRequestClient();

// Start the request. MyRequestClient callbacks will be executed asynchronously.
CefRefPtr<CefURLRequest> url_request = CefURLRequest::Create(request, client.get());
// To cancel the request: url_request->Cancel();

request->SetFlags(UR_FLAG_SKIP_CACHE | UR_FLAG_NO_DOWNLOAD_DATA);

void MyApp::OnRegisterCustomSchemes(CefRefPtr<CefSchemeRegistrar> registrar) {
  // Register "client" as a standard scheme.
  registrar->AddCustomScheme("client", true, false, false);
}

CefRegisterSchemeHandlerFactory("client", “myapp”, new MySchemeHandlerFactory());

 1 // Implementation of the factory for creating client request handlers.
 2 class MySchemeHandlerFactory : public CefSchemeHandlerFactory {
 3  public:
 4   virtual CefRefPtr<CefResourceHandler> Create(CefRefPtr<CefBrowser> browser,
 5                                                CefRefPtr<CefFrame> frame,
 6                                                const CefString& scheme_name,
 7                                                CefRefPtr<CefRequest> request)
 8                                                OVERRIDE {
 9     // Return a new resource handler instance to handle the request.
10     return new MyResourceHandler();
11   }
12 
13   IMPLEMENT_REFCOUNTING(MySchemeHandlerFactory);
14 };
15 
16 // Implementation of the resource handler for client requests.
17 class MyResourceHandler : public CefResourceHandler {
18  public:
19   MyResourceHandler() {}
20 
21   virtual bool ProcessRequest(CefRefPtr<CefRequest> request,
22                               CefRefPtr<CefCallback> callback)
23                               OVERRIDE {
24     // Evaluate |request| to determine proper handling...
25     // Execute |callback| once header information is available.
26     // Return true to handle the request.
27     return true;
28   }
29 
30   virtual void GetResponseHeaders(CefRefPtr<CefResponse> response,
31                                   int64& response_length,
32                                   CefString& redirectUrl) OVERRIDE {
33     // Populate the response headers.
34     response->SetMimeType("text/html");
35     response->SetStatus(200);
36 
37     // Specify the resulting response length.
38     response_length = ...;
39   }
40 
41   virtual void Cancel() OVERRIDE {
42     // Cancel the response...
43   }
44 
45   virtual bool ReadResponse(void* data_out,
46                             int bytes_to_read,
47                             int& bytes_read,
48                             CefRefPtr<CefCallback> callback)
49                             OVERRIDE {
50     // Read up to |bytes_to_read| data into |data_out| and set |bytes_read|.
51     // If data isn‘t immediately available set bytes_read=0 and execute
52     // |callback| asynchronously.
53     // Return true to continue the request or false to complete the request.
54     return …;
55   }
56 
57  private:
58   IMPLEMENT_REFCOUNTING(MyResourceHandler);
59 };

// CefStreamResourceHandler is part of the libcef_dll_wrapper project.
#include “include/wrapper/cef_stream_resource_handler.h”

const std::string& html_content = “<html><body>Hello!</body></html>”;

// Create a stream reader for |html_content|.
CefRefPtr<CefStreamReader> stream =
    CefStreamReader::CreateForData(
        static_cast<void*>(const_cast<char*>(html_content.c_str())),
        html_content.size());

// Constructor for HTTP status code 200 and no custom response headers.
// There’s also a version of the constructor for custom status code and response headers.
return new CefStreamResourceHandler("text/html", stream);

CefRefPtr<CefResourceHandler> MyHandler::GetResourceHandler(
      CefRefPtr<CefBrowser> browser,
      CefRefPtr<CefFrame> frame,
      CefRefPtr<CefRequest> request) {
  // Evaluate |request| to determine proper handling...
  if (...)
    return new MyResourceHandler();

  // Return NULL for default handling of the request.
  return NULL;
}

--proxy-server=host:port
      Specify the HTTP/SOCKS4/SOCKS5 proxy server to use for requests. An individual proxy
      server is specified using the format:

        [<proxy-scheme>://]<proxy-host>[:<proxy-port>]

      Where <proxy-scheme> is the protocol of the proxy server, and is one of:

        "http", "socks", "socks4", "socks5".

      If the <proxy-scheme> is omitted, it defaults to "http". Also note that "socks" is equivalent to
      "socks5".

      Examples:

        --proxy-server="foopy:99"
            Use the HTTP proxy "foopy:99" to load all URLs.

        --proxy-server="socks://foobar:1080"
            Use the SOCKS v5 proxy "foobar:1080" to load all URLs.

        --proxy-server="sock4://foobar:1080"
            Use the SOCKS v4 proxy "foobar:1080" to load all URLs.

        --proxy-server="socks5://foobar:66"
            Use the SOCKS v5 proxy "foobar:66" to load all URLs.

      It is also possible to specify a separate proxy server for different URL types, by prefixing
      the proxy server specifier with a URL specifier:

      Example:

        --proxy-server="https=proxy1:80;http=socks4://baz:1080"
            Load https://* URLs using the HTTP proxy "proxy1:80". And load http://*
            URLs using the SOCKS v4 proxy "baz:1080".

--no-proxy-server
      Disables the proxy server.

--proxy-auto-detect
      Autodetect  proxy  configuration.

--proxy-pac-url=URL
      Specify proxy autoconfiguration URL.

bool MyHandler::GetAuthCredentials(
    CefRefPtr<CefBrowser> browser,
    CefRefPtr<CefFrame> frame,
    bool isProxy,
    const CefString& host,
    int port,
    const CefString& realm,
    const CefString& scheme,
    CefRefPtr<CefAuthCallback> callback) {
  if (isProxy) {
    // Provide credentials for the proxy server connection.
    callback->Continue("myuser", "mypass");
    return true;
  }
  return false;
}