2.CEF常用接口类拦截请求回调函数

2      Cef常用接口类介绍

2.1     CefClient

2.2     CefContextMenuHandler右键菜单处理类

2.3     CefDisplayHandler网页显示处理类

2.4     CefDownloadHandler网页下载处理类

2.5     CefDragHandler鼠标拖动到网页处理类

2.6     CefKeyboardHandler键盘事件响应处理类

2.7     CefLifeSpanHandler生命周期处理类

2.7.1     DoClose标准关闭处理

2.7.2     DoClose非标准关闭处理

2.8     CefLoadHandler网页加载处理类

2.9     CefRequestHandler网络请求处理类

Cef是一个网页嵌入外壳，要获取网页的响应，拦截网页中的事件消息，CEF提供了一系列的接口回调类，提供各种事件回调函数，例如拦截获取键盘、鼠标、加载、显示、右键菜单、提示消息、状态变化、窗口打开关闭等，CEF都可以从网页上拦截捕捉消息事件，并通过回调函数传给应用程序进行处理。

2.1  CefClient

CefClient提供了获取各种handler的接口，例如上下文菜单handler、对话框handler、显示状态handler，下载事件handler、拖动事件handler、查找事件handler、键盘handler、生命周期事件handler、加载页面事件handler、离屏render进程handler、请求事件handler等。但是只是返回事件的handle。每个handler的具体的回调函数不在CefClient类中，需要继承各个handler类，才可以实现回调。CefClient类只有一个回调函数OnProcessMessageReceived用来处理进程间的通讯消息。CefClient的定义如下：

class CefClient : public virtual CefBaseRefCounted {

 public:

  ///

  // Return the handler for context menus. If no handler is provided the default

  // implementation will be used.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() {

    return NULL;

  }

 

  ///

  // Return the handler for dialogs. If no handler is provided the default

  // implementation will be used.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefDialogHandler> GetDialogHandler() { return NULL; }

 

  ///

  // Return the handler for browser display state events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() { return NULL; }

 

  ///

  // Return the handler for download events. If no handler is returned downloads

  // will not be allowed.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() { return NULL; }

 

  ///

  // Return the handler for drag events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefDragHandler> GetDragHandler() { return NULL; }

 

  ///

  // Return the handler for find result events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefFindHandler> GetFindHandler() { return NULL; }

 

  ///

  // Return the handler for focus events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefFocusHandler> GetFocusHandler() { return NULL; }

 

  ///

  // Return the handler for JavaScript dialogs. If no handler is provided the

  // default implementation will be used.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefJSDialogHandler> GetJSDialogHandler() { return NULL; }

 

  ///

  // Return the handler for keyboard events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() { return NULL; }

 

  ///

  // Return the handler for browser life span events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() { return NULL; }

 

  ///

  // Return the handler for browser load status events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() { return NULL; }

 

  ///

  // Return the handler for off-screen rendering events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefRenderHandler> GetRenderHandler() { return NULL; }

 

  ///

  // Return the handler for browser request events.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefRequestHandler> GetRequestHandler() { return NULL; }

 

  ///

  // Called when a new message is received from a different process. Return true

  // if the message was handled or false otherwise. Do not keep a reference to

  // or attempt to access the message outside of this callback.

  ///

  /*--cef()--*/

  virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,

                                        CefProcessId source_process,

                                        CefRefPtr<CefProcessMessage> message) {

    return false;

  }

};

2.2  CefContextMenuHandler右键菜单处理类

CefContextMenuHandler是网页上的右键菜单事件回调函数类，提供OnBeforeContextMenu回调函数，在右键菜单弹出之前修改或者禁用右键菜单。右键菜单按钮响应回调RunContextMenu、右键菜单命令回调OnContextMenuCommand菜单禁用回调函数OnContextMenuDismissed等。可以拦截右键菜单响应，进行自定义的处理。

class CefContextMenuHandler : public virtual CefBaseRefCounted {

 public:

  typedef cef_event_flags_t EventFlags;

 

  ///

  // Called before a context menu is displayed. |params| provides information

  // about the context menu state. |model| initially contains the default

  // context menu. The |model| can be cleared to show no context menu or

  // modified to show a custom menu. Do not keep references to |params| or

  // |model| outside of this callback.

  ///

  /*--cef()--*/

  virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,

                                   CefRefPtr<CefFrame> frame,

                                   CefRefPtr<CefContextMenuParams> params,

                                   CefRefPtr<CefMenuModel> model) {}

 

  ///

  // Called to allow custom display of the context menu. |params| provides

  // information about the context menu state. |model| contains the context menu

  // model resulting from OnBeforeContextMenu. For custom display return true

  // and execute |callback| either synchronously or asynchronously with the

  // selected command ID. For default display return false. Do not keep

  // references to |params| or |model| outside of this callback.

  ///

  /*--cef()--*/

  virtual bool RunContextMenu(CefRefPtr<CefBrowser> browser,

                              CefRefPtr<CefFrame> frame,

                              CefRefPtr<CefContextMenuParams> params,

                              CefRefPtr<CefMenuModel> model,

                              CefRefPtr<CefRunContextMenuCallback> callback) {

    return false;

  }

 

  ///

  // Called to execute a command selected from the context menu. Return true if

  // the command was handled or false for the default implementation. See

  // cef_menu_id_t for the command ids that have default implementations. All

  // user-defined command ids should be between MENU_ID_USER_FIRST and

  // MENU_ID_USER_LAST. |params| will have the same values as what was passed to

  // OnBeforeContextMenu(). Do not keep a reference to |params| outside of this

  // callback.

  ///

  /*--cef()--*/

  virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,

                                    CefRefPtr<CefFrame> frame,

                                    CefRefPtr<CefContextMenuParams> params,

                                    int command_id,

                                    EventFlags event_flags) {

    return false;

  }

  ///

  // Called when the context menu is dismissed irregardless of whether the menu

  // was empty or a command was selected.

  ///

  /*--cef()--*/

  virtual void OnContextMenuDismissed(CefRefPtr<CefBrowser> browser,

                                      CefRefPtr<CefFrame> frame) {}

};

 

2.3  CefDisplayHandler网页显示处理类

CefDisplayHandler提供了一些页面显示回调函数，例如网址发送变化OnAddressChange，网页标题OnTitleChange发生变化，网页图标发生变化OnFaviconURLChange，全屏变化OnFullscreenModeChange，显示提示消息OnTooltip，状态栏消息显示OnStatusMessage，控制台消息回调OnConsoleMessage，设置了自动调整大小回调OnAutoResize，加载进程变化回调OnLoadingProgressChange，CefDisplayHandler类定义如下

class CefDisplayHandler : public virtual CefBaseRefCounted {

 public:

  ///

  // Called when a frame's address has changed.

  ///

  /*--cef()--*/

  virtual void OnAddressChange(CefRefPtr<CefBrowser> browser,

                               CefRefPtr<CefFrame> frame,

                               const CefString& url) {}

 

  ///

  // Called when the page title changes.

  ///

  /*--cef(optional_param=title)--*/

  virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,

                             const CefString& title) {}

 

  ///

  // Called when the page icon changes.

  ///

  /*--cef(optional_param=icon_urls)--*/

  virtual void OnFaviconURLChange(CefRefPtr<CefBrowser> browser,

                                  const std::vector<CefString>& icon_urls) {}

 

  ///

  // Called when web content in the page has toggled fullscreen mode. If

  // |fullscreen| is true the content will automatically be sized to fill the

  // browser content area. If |fullscreen| is false the content will

  // automatically return to its original size and position. The client is

  // responsible for resizing the browser if desired.

  ///

  /*--cef()--*/

  virtual void OnFullscreenModeChange(CefRefPtr<CefBrowser> browser,

                                      bool fullscreen) {}

 

  ///

  // Called when the browser is about to display a tooltip. |text| contains the

  // text that will be displayed in the tooltip. To handle the display of the

  // tooltip yourself return true. Otherwise, you can optionally modify |text|

  // and then return false to allow the browser to display the tooltip.

  // When window rendering is disabled the application is responsible for

  // drawing tooltips and the return value is ignored.

  ///

  /*--cef(optional_param=text)--*/

  virtual bool OnTooltip(CefRefPtr<CefBrowser> browser, CefString& text) {

    return false;

  }

 

  ///

  // Called when the browser receives a status message. |value| contains the

  // text that will be displayed in the status message.

  ///

  /*--cef(optional_param=value)--*/

  virtual void OnStatusMessage(CefRefPtr<CefBrowser> browser,

                               const CefString& value) {}

 

  ///

  // Called to display a console message. Return true to stop the message from

  // being output to the console.

  ///

  /*--cef(optional_param=message,optional_param=source)--*/

  virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,

                                cef_log_severity_t level,

                                const CefString& message,

                                const CefString& source,

                                int line) {

    return false;

  }

 

  ///

  // Called when auto-resize is enabled via CefBrowserHost::SetAutoResizeEnabled

  // and the contents have auto-resized. |new_size| will be the desired size in

  // view coordinates. Return true if the resize was handled or false for

  // default handling.

  ///

  /*--cef()--*/

  virtual bool OnAutoResize(CefRefPtr<CefBrowser> browser,

                            const CefSize& new_size) {

    return false;

  }

 

  ///

  // Called when the overall page loading progress has changed. |progress|

  // ranges from 0.0 to 1.0.

  ///

  /*--cef()--*/

  virtual void OnLoadingProgressChange(CefRefPtr<CefBrowser> browser,

                                       double progress) {}

};

2.4  CefDownloadHandler网页下载处理类

CefDownloadHandler网页上下载文件类，提供开始从网页下载文件回调函数OnBeforeDownload，下载文件进度更新回调函数OnDownloadUpdated。

class CefDownloadHandler : public virtual CefBaseRefCounted {

 public:

  ///

  // Called before a download begins. |suggested_name| is the suggested name for

  // the download file. By default the download will be canceled. Execute

  // |callback| either asynchronously or in this method to continue the download

  // if desired. Do not keep a reference to |download_item| outside of this

  // method.

  ///

  /*--cef()--*/

  virtual void OnBeforeDownload(

      CefRefPtr<CefBrowser> browser,

      CefRefPtr<CefDownloadItem> download_item,

      const CefString& suggested_name,

      CefRefPtr<CefBeforeDownloadCallback> callback) = 0;

 

  ///

  // Called when a download's status or progress information has been updated.

  // This may be called multiple times before and after OnBeforeDownload().

  // Execute |callback| either asynchronously or in this method to cancel the

  // download if desired. Do not keep a reference to |download_item| outside of

  // this method.

  ///

  /*--cef()--*/

  virtual void OnDownloadUpdated(CefRefPtr<CefBrowser> browser,

                                 CefRefPtr<CefDownloadItem> download_item,

                                 CefRefPtr<CefDownloadItemCallback> callback) {}

};

 

2.5  CefDragHandler鼠标拖动到网页处理类

CefDragHandler处理鼠标拖动事件，提供鼠标拖动进入网页回调函数OnDragEnter，网页中可以拖动放入的区域发生变化回调函数OnDraggableRegionsChanged。

// Implement this interface to handle events related to dragging. The methods of

// this class will be called on the UI thread.

///

/*--cef(source=client)--*/

class CefDragHandler : public virtual CefBaseRefCounted {

 public:

  typedef cef_drag_operations_mask_t DragOperationsMask;

 

  ///

  // Called when an external drag event enters the browser window. |dragData|

  // contains the drag event data and |mask| represents the type of drag

  // operation. Return false for default drag handling behavior or true to

  // cancel the drag event.

  ///

  /*--cef()--*/

  virtual bool OnDragEnter(CefRefPtr<CefBrowser> browser,

                           CefRefPtr<CefDragData> dragData,

                           DragOperationsMask mask) {

    return false;

  }

 

  ///

  // Called whenever draggable regions for the browser window change. These can

  // be specified using the '-webkit-app-region: drag/no-drag' CSS-property. If

  // draggable regions are never defined in a document this method will also

  // never be called. If the last draggable region is removed from a document

  // this method will be called with an empty vector.

  ///

  /*--cef()--*/

  virtual void OnDraggableRegionsChanged(

      CefRefPtr<CefBrowser> browser,

      const std::vector<CefDraggableRegion>& regions) {}

};

 

2.6  CefKeyboardHandler键盘事件响应处理类

CefKeyboardHandler处理键盘响应事件，提供键盘按键响应回调函数。拦截键盘消息。

// Implement this interface to handle events related to keyboard input. The

// methods of this class will be called on the UI thread.

///

/*--cef(source=client)--*/

class CefKeyboardHandler : public virtual CefBaseRefCounted {

 public:

  ///

  // Called before a keyboard event is sent to the renderer. |event| contains

  // information about the keyboard event. |os_event| is the operating system

  // event message, if any. Return true if the event was handled or false

  // otherwise. If the event will be handled in OnKeyEvent() as a keyboard

  // shortcut set |is_keyboard_shortcut| to true and return false.

  ///

  /*--cef()--*/

  virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,

                             const CefKeyEvent& event,

                             CefEventHandle os_event,

                             bool* is_keyboard_shortcut) {

    return false;

  }

 

  ///

  // Called after the renderer and JavaScript in the page has had a chance to

  // handle the event. |event| contains information about the keyboard event.

  // |os_event| is the operating system event message, if any. Return true if

  // the keyboard event was handled or false otherwise.

  ///

  /*--cef()--*/

  virtual bool OnKeyEvent(CefRefPtr<CefBrowser> browser,

                          const CefKeyEvent& event,

                          CefEventHandle os_event) {

    return false;

  }

};

2.7  CefLifeSpanHandler生命周期处理类

CefLifeSpanHandler是生命周期处理类，新打开一个网页或者关闭一个网页时，会触发回调函数。OnBeforePopup这个只能在创建一个新的弹出式网页时，才会触发，如果是在一个网页中打开一个子网页，回调函数是拦截不到消息的。OnAfterCreated网页创建完成后的回调函数。browser销毁之前会触发回调函数OnBeforeClose。还有一个关闭回调函数DoClose有点复杂，当调用CefBrowserHost::*CloseBrowser()函数关闭browser，或者browser是CEF创建的顶层窗口的子窗口，当顶层窗口关闭时，也会触发关闭DoClose回调函数。点击网页的关闭按钮后，网页不会立刻关闭，而是会调用两次CloseBrowser()或TryCloseBrowser()，提供了一个让CEF处理JS的onbeforeunload事件和选择性取消关闭网页的机会。CefLifeSpanHandler类定义如下：

 

// Implement this interface to handle events related to browser life span. The

// methods of this class will be called on the UI thread unless otherwise

// indicated.

///

/*--cef(source=client)--*/

class CefLifeSpanHandler : public virtual CefBaseRefCounted {

 public:

  typedef cef_window_open_disposition_t WindowOpenDisposition;

 

  ///

  // Called on the UI thread before a new popup browser is created. The

  // |browser| and |frame| values represent the source of the popup request. The

  // |target_url| and |target_frame_name| values indicate where the popup

  // browser should navigate and may be empty if not specified with the request.

  // The |target_disposition| value indicates where the user intended to open

  // the popup (e.g. current tab, new tab, etc). The |user_gesture| value will

  // be true if the popup was opened via explicit user gesture (e.g. clicking a

  // link) or false if the popup opened automatically (e.g. via the

  // DomContentLoaded event). The |popupFeatures| structure contains additional

  // information about the requested popup window. To allow creation of the

  // popup browser optionally modify |windowInfo|, |client|, |settings| and

  // |no_javascript_access| and return false. To cancel creation of the popup

  // browser return true. The |client| and |settings| values will default to the

  // source browser's values. If the |no_javascript_access| value is set to

  // false the new browser will not be scriptable and may not be hosted in the

  // same renderer process as the source browser. Any modifications to

  // |windowInfo| will be ignored if the parent browser is wrapped in a

  // CefBrowserView. Popup browser creation will be canceled if the parent

  // browser is destroyed before the popup browser creation completes (indicated

  // by a call to OnAfterCreated for the popup browser).

  ///

  /*--cef(optional_param=target_url,optional_param=target_frame_name)--*/

  virtual bool OnBeforePopup(CefRefPtr<CefBrowser> browser,

                             CefRefPtr<CefFrame> frame,

                             const CefString& target_url,

                             const CefString& target_frame_name,

                             WindowOpenDisposition target_disposition,

                             bool user_gesture,

                             const CefPopupFeatures& popupFeatures,

                             CefWindowInfo& windowInfo,

                             CefRefPtr<CefClient>& client,

                             CefBrowserSettings& settings,

                             bool* no_javascript_access) {

    return false;

  }

 

  ///

  // Called after a new browser is created. This callback will be the first

  // notification that references |browser|.

  ///

  /*--cef()--*/

  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) {}

 

  ///

  // Called when a browser has recieved a request to close. This may result

  // directly from a call to CefBrowserHost::*CloseBrowser() or indirectly if

  // the browser is parented to a top-level window created by CEF and the user

  // attempts to close that window (by clicking the 'X', for example). The

  // DoClose() method will be called after the JavaScript 'onunload' event has

  // been fired.

  //

  // An application should handle top-level owner window close notifications by

  // calling CefBrowserHost::TryCloseBrowser() or

  // CefBrowserHost::CloseBrowser(false) instead of allowing the window to close

  // immediately (see the examples below). This gives CEF an opportunity to

  // process the 'onbeforeunload' event and optionally cancel the close before

  // DoClose() is called.

  //

  // When windowed rendering is enabled CEF will internally create a window or

  // view to host the browser. In that case returning false from DoClose() will

  // send the standard close notification to the browser's top-level owner

  // window (e.g. WM_CLOSE on Windows, performClose: on OS X, "delete_event" on

  // Linux or CefWindowDelegate::CanClose() callback from Views). If the

  // browser's host window/view has already been destroyed (via view hierarchy

  // tear-down, for example) then DoClose() will not be called for that browser

  // since is no longer possible to cancel the close.

  //

  // When windowed rendering is disabled returning false from DoClose() will

  // cause the browser object to be destroyed immediately.

  //

  // If the browser's top-level owner window requires a non-standard close

  // notification then send that notification from DoClose() and return true.

  //

  // The CefLifeSpanHandler::OnBeforeClose() method will be called after

  // DoClose() (if DoClose() is called) and immediately before the browser

  // object is destroyed. The application should only exit after OnBeforeClose()

  // has been called for all existing browsers.

  //

  // The below examples describe what should happen during window close when the

  // browser is parented to an application-provided top-level window.

  //

  // Example 1: Using CefBrowserHost::TryCloseBrowser(). This is recommended for

  // clients using standard close handling and windows created on the browser

  // process UI thread.

  // 1.  User clicks the window close button which sends a close notification to

  //     the application's top-level window.

  // 2.  Application's top-level window receives the close notification and

  //     calls TryCloseBrowser() (which internally calls CloseBrowser(false)).

  //     TryCloseBrowser() returns false so the client cancels the window close.

  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close

  //     confirmation dialog (which can be overridden via

  //     CefJSDialogHandler::OnBeforeUnloadDialog()).

  // 4.  User approves the close.

  // 5.  JavaScript 'onunload' handler executes.

  // 6.  CEF sends a close notification to the application's top-level window

  //     (because DoClose() returned false by default).

  // 7.  Application's top-level window receives the close notification and

  //     calls TryCloseBrowser(). TryCloseBrowser() returns true so the client

  //     allows the window close.

  // 8.  Application's top-level window is destroyed.

  // 9.  Application's OnBeforeClose() handler is called and the browser object

  //     is destroyed.

  // 10. Application exits by calling CefQuitMessageLoop() if no other browsers

  //     exist.

  //

  // Example 2: Using CefBrowserHost::CloseBrowser(false) and implementing the

  // DoClose() callback. This is recommended for clients using non-standard

  // close handling or windows that were not created on the browser process UI

  // thread.

  // 1.  User clicks the window close button which sends a close notification to

  //     the application's top-level window.

  // 2.  Application's top-level window receives the close notification and:

  //     A. Calls CefBrowserHost::CloseBrowser(false).

  //     B. Cancels the window close.

  // 3.  JavaScript 'onbeforeunload' handler executes and shows the close

  //     confirmation dialog (which can be overridden via

  //     CefJSDialogHandler::OnBeforeUnloadDialog()).

  // 4.  User approves the close.

  // 5.  JavaScript 'onunload' handler executes.

  // 6.  Application's DoClose() handler is called. Application will:

  //     A. Set a flag to indicate that the next close attempt will be allowed.

  //     B. Return false.

  // 7.  CEF sends an close notification to the application's top-level window.

  // 8.  Application's top-level window receives the close notification and

  //     allows the window to close based on the flag from #6B.

  // 9.  Application's top-level window is destroyed.

  // 10. Application's OnBeforeClose() handler is called and the browser object

  //     is destroyed.

  // 11. Application exits by calling CefQuitMessageLoop() if no other browsers

  //     exist.

  ///

  /*--cef()--*/

  virtual bool DoClose(CefRefPtr<CefBrowser> browser) { return false; }

 

  ///

  // Called just before a browser is destroyed. Release all references to the

  // browser object and do not attempt to execute any methods on the browser

  // object after this callback returns. This callback will be the last

  // notification that references |browser|. See DoClose() documentation for

  // additional usage information.

  ///

  /*--cef()--*/

  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) {}

};

 

2.7.1         DoClose标准关闭处理

当窗口创建是在browser进程的UI线程创建时，采用标准的关闭处理，使用CefBrowserHost::TryCloseBrowser()。不实现DoClose回调，默认返回false。具体步骤：

（1）   点击窗口的关闭按钮，发送一个关闭通知给顶层窗口。

（2）   顶层窗口接收到关闭通知，调用TryCloseBrowser()函数，返回false；

（3）   JS的onbeforeunload处理句柄执行显示关闭确认对话框。

（4）   用户点击按钮同意关闭；

（5）   JS的onunload处理句柄执行；

（6）   CEF发送一个close通知给顶层窗口；

（7）   定鞥窗口接收到关闭通知，调用TryCloseBrowser，返回true，表示允许关闭。

（8）   顶层窗口销毁

（9）   程序的OnBeforeClose处理回调函数执行，browser销毁.

（10）如果不存在其他browser，则调用CefQuitMessageLoop退出程序。

2.7.2         DoClose非标准关闭处理

当窗口不是在browser进程的UI线程中创建时，采用非标准的关闭处理，使用函数CefBrowserHost::CloseBrowser(false)，并且实现DoClose函数。

（1）   用户点击窗口的关闭按钮，发送一个关闭通知给顶层窗口。

（2）   顶层窗口接收到关闭通知，调用CefBrowserHost::CloseBrowser(false)函数，取消关闭；

（3）   JS的onbeforeunload处理句柄执行显示关闭确认对话框。

（4）   用户点击按钮同意关闭；

（5）   JS的onunload处理句柄执行；

（6）   程序的DoClose（）回调函数被调用，设置一个flag表明下次关闭尝试会被允许，返回false；

（7）   CEF发送一个close通知给顶层窗口；

（8）   顶层窗口接收到关闭通知，根据之前设置的flag判断是否关闭窗口。

（9）   顶层窗口销毁；

（10）程序的OnBeforeClose处理回调函数执行，browser销毁.

（11）如果不存在其他browser，则调用CefQuitMessageLoop退出程序。

 

2.8  CefLoadHandler网页加载处理类

在一个网页中加载内容，或者在网页中打开一个子frame，都可以拦截到iframe打开时的消息以及url等信息。可以拦截子网页url

（1）   开始加载OnLoadStart，navigation执行网之后，开始加载内容之前，回调此函数，多frame的进程会同时加载。同页面巡航不会调用。

（2）   加载结束OnLoadEnd，加载结束时回调，sub-frame在主frame加载结束后， 会继续开始加载或继续进行加载，同页面巡航不会调用。

（3）   加载错误OnLoadError，navigation失败或者取消是回调。

（4）   加载状态发生变化OnLoadingStateChange，加载初始化和加载结束时各调用一次，在OnLoadStart之前调用一次，OnLoadEnd或OnLoadError之后调用一次。

 

// Implement this interface to handle events related to browser load status. The

// methods of this class will be called on the browser process UI thread or

// render process main thread (TID_RENDERER).

///

/*--cef(source=client)--*/

class CefLoadHandler : public virtual CefBaseRefCounted {

 public:

  typedef cef_errorcode_t ErrorCode;

  typedef cef_transition_type_t TransitionType;

 

  ///

  // Called when the loading state has changed. This callback will be executed

  // twice -- once when loading is initiated either programmatically or by user

  // action, and once when loading is terminated due to completion, cancellation

  // of failure. It will be called before any calls to OnLoadStart and after all

  // calls to OnLoadError and/or OnLoadEnd.

  ///

  /*--cef()--*/

  virtual void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,

                                    bool isLoading,

                                    bool canGoBack,

                                    bool canGoForward) {}

 

  ///

  // Called after a navigation has been committed and before the browser begins

  // loading contents in the frame. The |frame| value will never be empty --

  // call the IsMain() method to check if this frame is the main frame.

  // |transition_type| provides information about the source of the navigation

  // and an accurate value is only available in the browser process. Multiple

  // frames may be loading at the same time. Sub-frames may start or continue

  // loading after the main frame load has ended. This method will not be called

  // for same page navigations (fragments, history state, etc.) or for

  // navigations that fail or are canceled before commit. For notification of

  // overall browser load status use OnLoadingStateChange instead.

  ///

  /*--cef()--*/

  virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,

                           CefRefPtr<CefFrame> frame,

                           TransitionType transition_type) {}

 

  ///

  // Called when the browser is done loading a frame. The |frame| value will

  // never be empty -- call the IsMain() method to check if this frame is the

  // main frame. Multiple frames may be loading at the same time. Sub-frames may

  // start or continue loading after the main frame load has ended. This method

  // will not be called for same page navigations (fragments, history state,

  // etc.) or for navigations that fail or are canceled before commit. For

  // notification of overall browser load status use OnLoadingStateChange

  // instead.

  ///

  /*--cef()--*/

  virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,

                         CefRefPtr<CefFrame> frame,

                         int httpStatusCode) {}

 

  ///

  // Called when a navigation fails or is canceled. This method may be called

  // by itself if before commit or in combination with OnLoadStart/OnLoadEnd if

  // after commit. |errorCode| is the error code number, |errorText| is the

  // error text and |failedUrl| is the URL that failed to load.

  // See net\base\net_error_list.h for complete descriptions of the error codes.

  ///

  /*--cef(optional_param=errorText)--*/

  virtual void OnLoadError(CefRefPtr<CefBrowser> browser,

                           CefRefPtr<CefFrame> frame,

                           ErrorCode errorCode,

                           const CefString& errorText,

                           const CefString& failedUrl) {}

};

 

2.9  CefRequestHandler网络请求处理类

当打开一个网页， CefRequestHandler的OnBeforeBrowser可以拦截网络请求，只有在新打开网页的时候，才会触发，如果网页已经打开，在网页内部点击查询按钮，查询内容，虽然也有request请求，但是OnBeforeBrowser拦截不到获取请求的URL，post请求的参数都可以获取到。OnResourceRedirect还可以拦截重定向请求。CefLoadHandler也可以拦截request请求，而且页面加载中调用很多的GET和POST请求都可以拦截到。测试发现CefRequestHandler页面内部的加载变化是获取不到的，只有打开页面的请求能获取到。而另外一个函数OnBeforeResourceLoad则可以拦截所有的请求，在浏览器中F12显示的所有请求，包括图片下载等请求都能一一获取。所以CefLoadHandler拦截的请求更详细一些，点击查询查询，OnLoadStart和OnLoadEnd 拦截不到，但是OnLoadingStateChange 可以拦截的到请求。

OnBeforeBrowser	打开新的网页可以拦截，页面内容变化，或者页面内部调用请求拦截不到。
OnBeforeResourceLoad	拦截一切请求，最详细。
OnResourceResponse	拦截一切请求，最详细。
OnLoadStart和OnLoadEnd	新打开页面可以拦截
OnLoadingStateChange	打开新页面， 页面内容重新加载，查询，按钮响应可以拦截。像一些图片加载，CSS加载是拦截不到的。第二详细。

 

各回调函的调用的先后顺序是

OnLoadingStateChange->OnBeforeBrowser->OnLoadStart->OnLoadEnd->OnLoadingStateChange。

// Implement this interface to handle events related to browser requests. The

// methods of this class will be called on the thread indicated.

///

/*--cef(source=client)--*/

class CefRequestHandler : public virtual CefBaseRefCounted {

 public:

  typedef cef_return_value_t ReturnValue;

  typedef cef_termination_status_t TerminationStatus;

  typedef cef_urlrequest_status_t URLRequestStatus;

  typedef cef_window_open_disposition_t WindowOpenDisposition;

  typedef std::vector<CefRefPtr<CefX509Certificate>> X509CertificateList;

 

  ///

  // Called on the UI thread before browser navigation. Return true to cancel

  // the navigation or false to allow the navigation to proceed. The |request|

  // object cannot be modified in this callback.

  // CefLoadHandler::OnLoadingStateChange will be called twice in all cases.

  // If the navigation is allowed CefLoadHandler::OnLoadStart and

  // CefLoadHandler::OnLoadEnd will be called. If the navigation is canceled

  // CefLoadHandler::OnLoadError will be called with an |errorCode| value of

  // ERR_ABORTED. The |user_gesture| value will be true if the browser

  // navigated via explicit user gesture (e.g. clicking a link) or false if it

  // navigated automatically (e.g. via the DomContentLoaded event).

  ///

  /*--cef()--*/

（1）OnBeforeBrowse，在浏览器巡航前调用。

  virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,

                              CefRefPtr<CefFrame> frame,

                              CefRefPtr<CefRequest> request,

                              bool user_gesture,

                              bool is_redirect) {

    return false;

  }

 

  ///

  // Called on the UI thread before OnBeforeBrowse in certain limited cases

  // where navigating a new or different browser might be desirable. This

  // includes user-initiated navigation that might open in a special way (e.g.

  // links clicked via middle-click or ctrl + left-click) and certain types of

  // cross-origin navigation initiated from the renderer process (e.g.

  // navigating the top-level frame to/from a file URL). The |browser| and

  // |frame| values represent the source of the navigation. The

  // |target_disposition| value indicates where the user intended to navigate

  // the browser based on standard Chromium behaviors (e.g. current tab,

  // new tab, etc). The |user_gesture| value will be true if the browser

  // navigated via explicit user gesture (e.g. clicking a link) or false if it

  // navigated automatically (e.g. via the DomContentLoaded event). Return true

  // to cancel the navigation or false to allow the navigation to proceed in the

  // source browser's top-level frame.

  ///

  /*--cef()--*/

（2）OnOpenURLFromTab，以特殊的方式打开的网页，例如鼠标中间按钮，快捷键等，一些很少的应用场景。

  virtual bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,

                                CefRefPtr<CefFrame> frame,

                                const CefString& target_url,

                                WindowOpenDisposition target_disposition,

                                bool user_gesture) {

    return false;

  }

 

  ///

  // Called on the IO thread before a resource request is loaded. The |request|

  // object may be modified. Return RV_CONTINUE to continue the request

  // immediately. Return RV_CONTINUE_ASYNC and call CefRequestCallback::

  // Continue() at a later time to continue or cancel the request

  // asynchronously. Return RV_CANCEL to cancel the request immediately.

  //

  ///

  /*--cef(default_retval=RV_CONTINUE)--*/

（3）OnBeforeResourceLoad网页开始加载资源时调用，可以拦截所有的请求，最为详细。

  virtual ReturnValue OnBeforeResourceLoad(

      CefRefPtr<CefBrowser> browser,

      CefRefPtr<CefFrame> frame,

      CefRefPtr<CefRequest> request,

      CefRefPtr<CefRequestCallback> callback) {

    return RV_CONTINUE;

  }

};

///

  // Called on the IO thread before a resource is loaded. To allow the resource

  // to load normally return NULL. To specify a handler for the resource return

  // a CefResourceHandler object. The |request| object should not be modified in

  // this callback.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefResourceHandler> GetResourceHandler(

      CefRefPtr<CefBrowser> browser,

      CefRefPtr<CefFrame> frame,

      CefRefPtr<CefRequest> request) {

    return NULL;

  }

 

  ///

  // Called on the IO thread when a resource load is redirected. The |request|

  // parameter will contain the old URL and other request-related information.

  // The |response| parameter will contain the response that resulted in the

  // redirect. The |new_url| parameter will contain the new URL and can be

  // changed if desired. The |request| object cannot be modified in this

  // callback.

  ///

  /*--cef()--*/

（4）OnResourceRedirect重定向请求拦截

  virtual void OnResourceRedirect(CefRefPtr<CefBrowser> browser,

                                  CefRefPtr<CefFrame> frame,

                                  CefRefPtr<CefRequest> request,

                                  CefRefPtr<CefResponse> response,

                                  CefString& new_url) {}

 

  ///

  // Called on the IO thread when a resource response is received. To allow the

  // resource to load normally return false. To redirect or retry the resource

  // modify |request| (url, headers or post body) and return true. The

  // |response| object cannot be modified in this callback.

  ///

  /*--cef()--*/

（5）OnResourceResponse请求响应后的回调函数

  virtual bool OnResourceResponse(CefRefPtr<CefBrowser> browser,

                                  CefRefPtr<CefFrame> frame,

                                  CefRefPtr<CefRequest> request,

                                  CefRefPtr<CefResponse> response) {

    return false;

  }

 

  ///

  // Called on the IO thread to optionally filter resource response content.

  // |request| and |response| represent the request and response respectively

  // and cannot be modified in this callback.

  ///

  /*--cef()--*/

  virtual CefRefPtr<CefResponseFilter> GetResourceResponseFilter(

      CefRefPtr<CefBrowser> browser,

      CefRefPtr<CefFrame> frame,

      CefRefPtr<CefRequest> request,

      CefRefPtr<CefResponse> response) {

    return NULL;

  }

///

  // Called on the IO thread when a resource load has completed. |request| and

  // |response| represent the request and response respectively and cannot be

  // modified in this callback. |status| indicates the load completion status.

  // |received_content_length| is the number of response bytes actually read.

  ///

  /*--cef()--*/

（6）OnResourceLoadComplete资源加载结束时的回调

  virtual void OnResourceLoadComplete(CefRefPtr<CefBrowser> browser,

                                      CefRefPtr<CefFrame> frame,

                                      CefRefPtr<CefRequest> request,

                                      CefRefPtr<CefResponse> response,

                                      URLRequestStatus status,

                                      int64 received_content_length) {}

 

  ///

  // Called on the IO thread when the browser needs credentials from the user.

  // |isProxy| indicates whether the host is a proxy server. |host| contains the

  // hostname and |port| contains the port number. |realm| is the realm of the

  // challenge and may be empty. |scheme| is the authentication scheme used,

  // such as "basic" or "digest", and will be empty if the source of the request

  // is an FTP server. Return true to continue the request and call

  // CefAuthCallback::Continue() either in this method or at a later time when

  // the authentication information is available. Return false to cancel the

  // request immediately.

  ///

  /*--cef(optional_param=realm,optional_param=scheme)--*/

  virtual bool GetAuthCredentials(CefRefPtr<CefBrowser> browser,

                                  CefRefPtr<CefFrame> frame,

                                  bool isProxy,

                                  const CefString& host,

                                  int port,

                                  const CefString& realm,

                                  const CefString& scheme,

                                  CefRefPtr<CefAuthCallback> callback) {

    return false;

  }

 

  ///

  // Called on the IO thread before sending a network request with a "Cookie"

  // request header. Return true to allow cookies to be included in the network

  // request or false to block cookies. The |request| object should not be

  // modified in this callback.

  ///

  /*--cef()--*/

  virtual bool CanGetCookies(CefRefPtr<CefBrowser> browser,

                             CefRefPtr<CefFrame> frame,

                             CefRefPtr<CefRequest> request) {

    return true;

  }

 

  ///

  // Called on the IO thread when receiving a network request with a

  // "Set-Cookie" response header value represented by |cookie|. Return true to

  // allow the cookie to be stored or false to block the cookie. The |request|

  // object should not be modified in this callback.

  ///

  /*--cef()--*/

  virtual bool CanSetCookie(CefRefPtr<CefBrowser> browser,

                            CefRefPtr<CefFrame> frame,

                            CefRefPtr<CefRequest> request,

                            const CefCookie& cookie) {

    return true;

  }

 

  ///

  // Called on the IO thread when JavaScript requests a specific storage quota

  // size via the webkitStorageInfo.requestQuota function. |origin_url| is the

  // origin of the page making the request. |new_size| is the requested quota

  // size in bytes. Return true to continue the request and call

  // CefRequestCallback::Continue() either in this method or at a later time to

  // grant or deny the request. Return false to cancel the request immediately.

  ///

  /*--cef()--*/

  virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,

                              const CefString& origin_url,

                              int64 new_size,

                              CefRefPtr<CefRequestCallback> callback) {

    return false;

  }

 

  ///

  // Called on the UI thread to handle requests for URLs with an unknown

  // protocol component. Set |allow_os_execution| to true to attempt execution

  // via the registered OS protocol handler, if any.

  // SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED

  // ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.

  ///

  /*--cef()--*/

  virtual void OnProtocolExecution(CefRefPtr<CefBrowser> browser,

                                   const CefString& url,

                                   bool& allow_os_execution) {}

 

  ///

  // Called on the UI thread to handle requests for URLs with an invalid

  // SSL certificate. Return true and call CefRequestCallback::Continue() either

  // in this method or at a later time to continue or cancel the request. Return

  // false to cancel the request immediately. If

  // CefSettings.ignore_certificate_errors is set all invalid certificates will

  // be accepted without calling this method.

  ///

  /*--cef()--*/

  virtual bool OnCertificateError(CefRefPtr<CefBrowser> browser,

                                  cef_errorcode_t cert_error,

                                  const CefString& request_url,

                                  CefRefPtr<CefSSLInfo> ssl_info,

                                  CefRefPtr<CefRequestCallback> callback) {

    return false;

  }

 

  ///

  // Called on the UI thread when a client certificate is being requested for

  // authentication. Return false to use the default behavior and automatically

  // select the first certificate available. Return true and call

  // CefSelectClientCertificateCallback::Select either in this method or at a

  // later time to select a certificate. Do not call Select or call it with NULL

  // to continue without using any certificate. |isProxy| indicates whether the

  // host is an HTTPS proxy or the origin server. |host| and |port| contains the

  // hostname and port of the SSL server. |certificates| is the list of

  // certificates to choose from; this list has already been pruned by Chromium

  // so that it only contains certificates from issuers that the server trusts.

  ///

  /*--cef()--*/

  virtual bool OnSelectClientCertificate(

      CefRefPtr<CefBrowser> browser,

      bool isProxy,

      const CefString& host,

      int port,

      const X509CertificateList& certificates,

      CefRefPtr<CefSelectClientCertificateCallback> callback) {

    return false;

  }

 

  ///

  // Called on the browser process UI thread when a plugin has crashed.

  // |plugin_path| is the path of the plugin that crashed.

  ///

  /*--cef()--*/

  virtual void OnPluginCrashed(CefRefPtr<CefBrowser> browser,

                               const CefString& plugin_path) {}

 

  ///

  // Called on the browser process UI thread when the render view associated

  // with |browser| is ready to receive/handle IPC messages in the render

  // process.

  ///

  /*--cef()--*/

  virtual void OnRenderViewReady(CefRefPtr<CefBrowser> browser) {}

///

  // Called on the browser process UI thread when the render process

  // terminates unexpectedly. |status| indicates how the process

  // terminated.

  ///

  /*--cef()--*/

  virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,

                                         TerminationStatus status) {}

};

自己开发了一个股票智能分析软件，功能很强大，需要的点击下面的链接获取：

https://www.cnblogs.com/bclshuai/p/11380657.html