288 lines
10 KiB
C++
288 lines
10 KiB
C++
// Copyright (c) 2011 The Chromium Embedded Framework Authors. All rights
|
|
// reserved. Use of this source code is governed by a BSD-style license that
|
|
// can be found in the LICENSE file.
|
|
|
|
#ifndef CEF_TESTS_CEFCLIENT_CLIENT_HANDLER_H_
|
|
#define CEF_TESTS_CEFCLIENT_CLIENT_HANDLER_H_
|
|
#pragma once
|
|
|
|
#include <map>
|
|
#include <set>
|
|
#include <string>
|
|
#include "include/cef_client.h"
|
|
#include "cefclient/util.h"
|
|
|
|
|
|
// Define this value to redirect all popup URLs to the main application browser
|
|
// window.
|
|
// #define TEST_REDIRECT_POPUP_URLS
|
|
|
|
|
|
// ClientHandler implementation.
|
|
class ClientHandler : public CefClient,
|
|
public CefContextMenuHandler,
|
|
public CefDisplayHandler,
|
|
public CefDownloadHandler,
|
|
public CefGeolocationHandler,
|
|
public CefKeyboardHandler,
|
|
public CefLifeSpanHandler,
|
|
public CefLoadHandler,
|
|
public CefRequestHandler {
|
|
public:
|
|
// Interface for process message delegates. Do not perform work in the
|
|
// RenderDelegate constructor.
|
|
class ProcessMessageDelegate : public virtual CefBase {
|
|
public:
|
|
// Called when a process message is received. Return true if the message was
|
|
// handled and should not be passed on to other handlers.
|
|
// ProcessMessageDelegates should check for unique message names to avoid
|
|
// interfering with each other.
|
|
virtual bool OnProcessMessageReceived(
|
|
CefRefPtr<ClientHandler> handler,
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefProcessId source_process,
|
|
CefRefPtr<CefProcessMessage> message) {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
typedef std::set<CefRefPtr<ProcessMessageDelegate> >
|
|
ProcessMessageDelegateSet;
|
|
|
|
// Interface for request handler delegates. Do not perform work in the
|
|
// RequestDelegate constructor.
|
|
class RequestDelegate : public virtual CefBase {
|
|
public:
|
|
// Called to retrieve a resource handler.
|
|
virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
|
|
CefRefPtr<ClientHandler> handler,
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request) {
|
|
return NULL;
|
|
}
|
|
};
|
|
|
|
typedef std::set<CefRefPtr<RequestDelegate> > RequestDelegateSet;
|
|
|
|
ClientHandler();
|
|
virtual ~ClientHandler();
|
|
|
|
// CefClient methods
|
|
virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefGeolocationHandler> GetGeolocationHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual CefRefPtr<CefRequestHandler> GetRequestHandler() OVERRIDE {
|
|
return this;
|
|
}
|
|
virtual bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
|
|
CefProcessId source_process,
|
|
CefRefPtr<CefProcessMessage> message)
|
|
OVERRIDE;
|
|
|
|
// CefContextMenuHandler methods
|
|
virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefContextMenuParams> params,
|
|
CefRefPtr<CefMenuModel> model) OVERRIDE;
|
|
virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefContextMenuParams> params,
|
|
int command_id,
|
|
EventFlags event_flags) OVERRIDE;
|
|
|
|
// CefDisplayHandler methods
|
|
virtual void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) OVERRIDE;
|
|
virtual void OnAddressChange(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& url) OVERRIDE;
|
|
virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,
|
|
const CefString& title) OVERRIDE;
|
|
virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
|
|
const CefString& message,
|
|
const CefString& source,
|
|
int line) OVERRIDE;
|
|
|
|
// CefDownloadHandler methods
|
|
virtual void OnBeforeDownload(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefDownloadItem> download_item,
|
|
const CefString& suggested_name,
|
|
CefRefPtr<CefBeforeDownloadCallback> callback) OVERRIDE;
|
|
virtual void OnDownloadUpdated(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefDownloadItem> download_item,
|
|
CefRefPtr<CefDownloadItemCallback> callback) OVERRIDE;
|
|
|
|
// CefGeolocationHandler methods
|
|
virtual void OnRequestGeolocationPermission(
|
|
CefRefPtr<CefBrowser> browser,
|
|
const CefString& requesting_url,
|
|
int request_id,
|
|
CefRefPtr<CefGeolocationCallback> callback) OVERRIDE;
|
|
|
|
// CefKeyboardHandler methods
|
|
virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
|
|
const CefKeyEvent& event,
|
|
CefEventHandle os_event,
|
|
bool* is_keyboard_shortcut) OVERRIDE;
|
|
|
|
// CefLifeSpanHandler methods
|
|
virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
|
|
virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
|
|
virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
|
|
|
|
// CefLoadHandler methods
|
|
virtual void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) OVERRIDE;
|
|
virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) OVERRIDE;
|
|
virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) OVERRIDE;
|
|
virtual void OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
|
|
TerminationStatus status) OVERRIDE;
|
|
|
|
// CefRequestHandler methods
|
|
virtual CefRefPtr<CefResourceHandler> GetResourceHandler(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request) OVERRIDE;
|
|
virtual bool OnQuotaRequest(CefRefPtr<CefBrowser> browser,
|
|
const CefString& origin_url,
|
|
int64 new_size,
|
|
CefRefPtr<CefQuotaCallback> callback) OVERRIDE;
|
|
virtual void OnProtocolExecution(CefRefPtr<CefBrowser> browser,
|
|
const CefString& url,
|
|
bool& allow_os_execution) OVERRIDE;
|
|
|
|
void SetMainHwnd(CefWindowHandle hwnd);
|
|
CefWindowHandle GetMainHwnd() { return m_MainHwnd; }
|
|
void SetEditHwnd(CefWindowHandle hwnd);
|
|
void SetButtonHwnds(CefWindowHandle backHwnd,
|
|
CefWindowHandle forwardHwnd,
|
|
CefWindowHandle reloadHwnd,
|
|
CefWindowHandle stopHwnd);
|
|
|
|
CefRefPtr<CefBrowser> GetBrowser() { return m_Browser; }
|
|
int GetBrowserId() { return m_BrowserId; }
|
|
|
|
std::string GetLogFile();
|
|
|
|
void SetLastDownloadFile(const std::string& fileName);
|
|
std::string GetLastDownloadFile();
|
|
|
|
// Send a notification to the application. Notifications should not block the
|
|
// caller.
|
|
enum NotificationType {
|
|
NOTIFY_CONSOLE_MESSAGE,
|
|
NOTIFY_DOWNLOAD_COMPLETE,
|
|
NOTIFY_DOWNLOAD_ERROR,
|
|
};
|
|
void SendNotification(NotificationType type);
|
|
void CloseMainWindow();
|
|
|
|
void ShowDevTools(CefRefPtr<CefBrowser> browser);
|
|
|
|
// Returns the startup URL.
|
|
std::string GetStartupURL() { return m_StartupURL; }
|
|
|
|
// Create an external browser window that loads the specified URL.
|
|
static void LaunchExternalBrowser(const std::string& url);
|
|
|
|
protected:
|
|
void SetLoading(bool isLoading);
|
|
void SetNavState(bool canGoBack, bool canGoForward);
|
|
|
|
// Create all of ProcessMessageDelegate objects.
|
|
static void CreateProcessMessageDelegates(
|
|
ProcessMessageDelegateSet& delegates);
|
|
|
|
// Create all of RequestDelegateSet objects.
|
|
static void CreateRequestDelegates(RequestDelegateSet& delegates);
|
|
|
|
// Test context menu creation.
|
|
void BuildTestMenu(CefRefPtr<CefMenuModel> model);
|
|
bool ExecuteTestMenu(int command_id);
|
|
struct TestMenuState {
|
|
TestMenuState() : check_item(true), radio_item(0) {}
|
|
bool check_item;
|
|
int radio_item;
|
|
} m_TestMenuState;
|
|
|
|
// Returns the full download path for the specified file, or an empty path to
|
|
// use the default temp directory.
|
|
std::string GetDownloadPath(const std::string& file_name);
|
|
|
|
// The child browser window
|
|
CefRefPtr<CefBrowser> m_Browser;
|
|
|
|
// The main frame window handle
|
|
CefWindowHandle m_MainHwnd;
|
|
|
|
// The child browser id
|
|
int m_BrowserId;
|
|
|
|
// The edit window handle
|
|
CefWindowHandle m_EditHwnd;
|
|
|
|
// The button window handles
|
|
CefWindowHandle m_BackHwnd;
|
|
CefWindowHandle m_ForwardHwnd;
|
|
CefWindowHandle m_StopHwnd;
|
|
CefWindowHandle m_ReloadHwnd;
|
|
|
|
// Support for logging.
|
|
std::string m_LogFile;
|
|
|
|
// Support for downloading files.
|
|
std::string m_LastDownloadFile;
|
|
|
|
// True if an editable field currently has focus.
|
|
bool m_bFocusOnEditableField;
|
|
|
|
// Registered delegates.
|
|
ProcessMessageDelegateSet process_message_delegates_;
|
|
RequestDelegateSet request_delegates_;
|
|
|
|
// If true DevTools will be opened in an external browser window.
|
|
bool m_bExternalDevTools;
|
|
|
|
// List of open DevTools URLs if not using an external browser window.
|
|
std::set<std::string> m_OpenDevToolsURLs;
|
|
|
|
// The startup URL.
|
|
std::string m_StartupURL;
|
|
|
|
// Include the default reference counting implementation.
|
|
IMPLEMENT_REFCOUNTING(ClientHandler);
|
|
// Include the default locking implementation.
|
|
IMPLEMENT_LOCKING(ClientHandler);
|
|
};
|
|
|
|
#endif // CEF_TESTS_CEFCLIENT_CLIENT_HANDLER_H_
|