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 CefClientCefClient提供了获取各种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 可以拦截的到请求。
各回调函的调用的先后顺序是 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) {} }; 自己开发了一个股票智能分析软件,功能很强大,需要的点击下面的链接获取: |
|
来自: 猎狐肥 > 《Chrome_Cef》