bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Significant API changes for issue #218:

Browse Source 
- Replace CefHandler with a new CefClient interface and separate handler interfaces.
- Add support for virtual inheritance to allow multiple CefBase parented interfaces to be implemented in the same class.
- Replace CefThreadSafeBase with IMPLEMENT_* macros to support virtual inheritance and to only provide locking implementations when needed.
- Move the CefBrowserSettings parameter from CefInitialize to CreateBrowser.
- Add a new cef_build.h header that provides platform-specific and OS_* defines.
- Introduce the use of OVERRIDE to generate compiler errors on Windows if a child virtual method declaration doesn't match the parent declaration.
- Use NDEBUG instead of _DEBUG because _DEBUG is not defined on Mac. (issue #240).

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@235 5089003a-bbd8-11dd-ad1f-f1f9622dbc98
This commit is contained in:
Marshall Greenblatt
2011-05-20 14:42:25 +00:00
parent 9a69e96950
commit dbe8de277f
251 changed files with 7127 additions and 4945 deletions
Download Patch File Download Diff File Expand all files Collapse all files

527
tests/cefclient/cefclient.h
View File

@@ -1,4 +1,4 @@
// Copyright (c) 2008 The Chromium Embedded Framework Authors. All rights
// 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.
@@ -6,531 +6,6 @@
#define _CEFCLIENT_H
#include "include/cef.h"
#include "download_handler.h"
#include "util.h"
// Define this value to redirect all popup URLs to the main application browser
// window.
//#define TEST_REDIRECT_POPUP_URLS
// Client implementation of the browser handler class
class ClientHandler : public CefThreadSafeBase<CefHandler>
{
public:
// Implements the DownloadListener interface.
class ClientDownloadListener : public CefThreadSafeBase<DownloadListener>
{
public:
ClientDownloadListener(ClientHandler* handler) : handler_(handler) {}
// Called when the download is complete.
virtual void NotifyDownloadComplete(const CefString& fileName);
// Called if the download fails.
virtual void NotifyDownloadError(const CefString& fileName);
private:
ClientHandler* handler_;
};
ClientHandler();
virtual ~ClientHandler();
// Called on the UI thread before a new window is created. The |parentBrowser|
// parameter will point to the parent browser window, if any. The |popup|
// parameter will be true if the new window is a popup window, in which case
// |popupFeatures| will contain information about the style of popup window
// requested. If you create the window yourself you should populate the window
// handle member of |createInfo| and return RV_HANDLED. Otherwise, return
// RV_CONTINUE and the framework will create the window. By default, a newly
// created window will recieve the same handler as the parent window. To
// change the handler for the new window modify the object that |handler|
// points to.
virtual RetVal HandleBeforeCreated(CefRefPtr<CefBrowser> parentBrowser,
CefWindowInfo& createInfo, bool popup,
const CefPopupFeatures& popupFeatures,
CefRefPtr<CefHandler>& handler,
const CefString& url,
CefBrowserSettings& settings);
// Called on the UI thread after a new window is created. The return value is
// currently ignored.
virtual RetVal HandleAfterCreated(CefRefPtr<CefBrowser> browser);
// Called on the UI thread when a frame's address has changed. The return
// value is currently ignored.
virtual RetVal HandleAddressChange(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const CefString& url);
// Called on the UI thread when the page title changes. The return value is
// currently ignored.
virtual RetVal HandleTitleChange(CefRefPtr<CefBrowser> browser,
const CefString& title);
// Called on the UI thread when the navigation state has changed. The return
// value is currently ignored.
virtual RetVal HandleNavStateChange(CefRefPtr<CefBrowser> browser,
bool canGoBack, bool canGoForward);
// Called on the UI thread before browser navigation. The client has an
// opportunity to modify the |request| object if desired. Return RV_HANDLED
// to cancel navigation.
virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
NavType navType, bool isRedirect)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread when the browser begins 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 may not be called for a particular frame if the load
// request for that frame fails. The return value is currently ignored.
virtual RetVal HandleLoadStart(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame);
// Called on the UI thread 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 always be called for all frames irrespective of
// whether the request completes successfully. The return value is currently
// ignored.
virtual RetVal HandleLoadEnd(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
int httpStatusCode);
// Called on the UI thread when the browser fails to load a resource.
// |errorCode| is the error code number and |failedUrl| is the URL that failed
// to load. To provide custom error text assign the text to |errorText| and
// return RV_HANDLED. Otherwise, return RV_CONTINUE for the default error
// text.
virtual RetVal HandleLoadError(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
ErrorCode errorCode,
const CefString& failedUrl,
CefString& errorText);
// Called on the IO thread before a resource is loaded. To allow the resource
// to load normally return RV_CONTINUE. To redirect the resource to a new url
// populate the |redirectUrl| value and return RV_CONTINUE. To specify data
// for the resource return a CefStream object in |resourceStream|, set
// |mimeType| to the resource stream's mime type, and return RV_CONTINUE. To
// cancel loading of the resource return RV_HANDLED. Any modifications to
// |request| will be observed. If the URL in |request| is changed and
// |redirectUrl| is also set, the URL in |request| will be used.
virtual RetVal HandleBeforeResourceLoad(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefRequest> request,
CefString& redirectUrl,
CefRefPtr<CefStreamReader>& resourceStream,
CefRefPtr<CefResponse> response,
int loadFlags);
// Called on the IO thread to handle requests for URLs with an unknown
// protocol component. Return RV_HANDLED to indicate that the request should
// succeed because it was externally handled. Set |allow_os_execution| to true
// and return RV_CONTINUE to attempt execution via the registered OS protocol
// handler, if any. If RV_CONTINUE is returned and either |allow_os_execution|
// is false or OS protocol handler execution fails then the request will fail
// with an error condition.
// SECURITY WARNING: YOU SHOULD USE THIS METHOD TO ENFORCE RESTRICTIONS BASED
// ON SCHEME, HOST OR OTHER URL ANALYSIS BEFORE ALLOWING OS EXECUTION.
virtual RetVal HandleProtocolExecution(CefRefPtr<CefBrowser> browser,
const CefString& url,
bool& allow_os_execution)
{
REQUIRE_IO_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread when a server indicates via the
// 'Content-Disposition' header that a response represents a file to download.
// |mimeType| is the mime type for the download, |fileName| is the suggested
// target file name and |contentLength| is either the value of the
// 'Content-Size' header or -1 if no size was provided. Set |handler| to the
// CefDownloadHandler instance that will recieve the file contents. Return
// RV_CONTINUE to download the file or RV_HANDLED to cancel the file download.
virtual RetVal HandleDownloadResponse(CefRefPtr<CefBrowser> browser,
const CefString& mimeType,
const CefString& fileName,
int64 contentLength,
CefRefPtr<CefDownloadHandler>& handler);
// 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 number. Set |username| and |password| and return
// RV_HANDLED to handle the request. Return RV_CONTINUE to cancel the request.
virtual RetVal HandleAuthenticationRequest(CefRefPtr<CefBrowser> browser,
bool isProxy,
const CefString& host,
const CefString& realm,
const CefString& scheme,
CefString& username,
CefString& password)
{
REQUIRE_IO_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread before a context menu is displayed. To cancel
// display of the default context menu return RV_HANDLED.
virtual RetVal HandleBeforeMenu(CefRefPtr<CefBrowser> browser,
const MenuInfo& menuInfo)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to optionally override the default text for a
// context menu item. |label| contains the default text and may be modified to
// substitute alternate text. The return value is currently ignored.
virtual RetVal HandleGetMenuLabel(CefRefPtr<CefBrowser> browser,
MenuId menuId, CefString& label)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread when an option is selected from the default context
// menu. Return RV_HANDLED to cancel default handling of the action.
virtual RetVal HandleMenuAction(CefRefPtr<CefBrowser> browser,
MenuId menuId)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to allow customization of standard print options
// before the print dialog is displayed. |printOptions| allows specification
// of paper size, orientation and margins. Note that the specified margins may
// be adjusted if they are outside the range supported by the printer. All
// units are in inches. Return RV_CONTINUE to display the default print
// options or RV_HANDLED to display the modified |printOptions|.
virtual RetVal HandlePrintOptions(CefRefPtr<CefBrowser> browser,
CefPrintOptions& printOptions)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to format print headers and footers. |printInfo|
// contains platform-specific information about the printer context. |url| is
// the URL if the currently printing page, |title| is the title of the
// currently printing page, |currentPage| is the current page number and
// |maxPages| is the total number of pages. Six default header locations are
// provided by the implementation: top left, top center, top right, bottom
// left, bottom center and bottom right. To use one of these default locations
// just assign a string to the appropriate variable. To draw the header and
// footer yourself return RV_HANDLED. Otherwise, populate the approprate
// variables and return RV_CONTINUE.
virtual RetVal HandlePrintHeaderFooter(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefPrintInfo& printInfo,
const CefString& url,
const CefString& title,
int currentPage, int maxPages,
CefString& topLeft,
CefString& topCenter,
CefString& topRight,
CefString& bottomLeft,
CefString& bottomCenter,
CefString& bottomRight);
// Called on the UI thread to run a JS alert message. Return RV_CONTINUE to
// display the default alert or RV_HANDLED if you displayed a custom alert.
virtual RetVal HandleJSAlert(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const CefString& message)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to run a JS confirm request. Return RV_CONTINUE to
// display the default alert or RV_HANDLED if you displayed a custom alert. If
// you handled the alert set |retval| to true if the user accepted the
// confirmation.
virtual RetVal HandleJSConfirm(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const CefString& message, bool& retval)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to run a JS prompt request. Return RV_CONTINUE to
// display the default prompt or RV_HANDLED if you displayed a custom prompt.
// If you handled the prompt set |retval| to true if the user accepted the
// prompt and request and |result| to the resulting value.
virtual RetVal HandleJSPrompt(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
const CefString& message,
const CefString& defaultValue,
bool& retval,
CefString& result)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread for adding values to a frame's JavaScript 'window'
// object. The return value is currently ignored.
virtual RetVal HandleJSBinding(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefV8Value> object);
// Called on the UI thread just before a window is closed. The return value is
// currently ignored.
virtual RetVal HandleBeforeWindowClose(CefRefPtr<CefBrowser> browser);
// Called on the UI thread when the browser component is about to loose focus.
// For instance, if focus was on the last HTML element and the user pressed
// the TAB key. The return value is currently ignored.
virtual RetVal HandleTakeFocus(CefRefPtr<CefBrowser> browser, bool reverse)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread when the browser component is requesting focus.
// |isWidget| will be true if the focus is requested for a child widget of the
// browser window. Return RV_CONTINUE to allow the focus to be set or
// RV_HANDLED to cancel setting the focus.
virtual RetVal HandleSetFocus(CefRefPtr<CefBrowser> browser,
bool isWidget)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread when the browser component receives a keyboard
// event. |type| is the type of keyboard event, |code| is the windows scan-
// code for the event, |modifiers| is a set of bit-flags describing any
// pressed modifier keys and |isSystemKey| is true if Windows considers this a
// 'system key' message (see
// http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx). Return
// RV_HANDLED if the keyboard event was handled or RV_CONTINUE to allow the
// browser component to handle the event.
virtual RetVal HandleKeyEvent(CefRefPtr<CefBrowser> browser,
KeyEventType type,
int code,
int modifiers,
bool isSystemKey)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread 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 RV_HANDLED. Otherwise, you can
// optionally modify |text| and then return RV_CONTINUE to allow the browser
// to display the tooltip.
virtual RetVal HandleTooltip(CefRefPtr<CefBrowser> browser,
CefString& text)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread when the browser has a status message. |text|
// contains the text that will be displayed in the status message and |type|
// indicates the status message type. The return value is currently ignored.
virtual RetVal HandleStatus(CefRefPtr<CefBrowser> browser,
const CefString& text, StatusType type)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to display a console message. Return RV_HANDLED to
// stop the message from being output to the console.
virtual RetVal HandleConsoleMessage(CefRefPtr<CefBrowser> browser,
const CefString& message,
const CefString& source, int line);
// Called on the UI thread to report find results returned by
// CefBrowser::Find(). |identifer| is the identifier passed to
// CefBrowser::Find(), |count| is the number of matches currently identified,
// |selectionRect| is the location of where the match was found (in window
// coordinates), |activeMatchOrdinal| is the current position in the search
// results, and |finalUpdate| is true if this is the last find notification.
// The return value is currently ignored.
virtual RetVal HandleFindResult(CefRefPtr<CefBrowser> browser,
int identifier, int count,
const CefRect& selectionRect,
int activeMatchOrdinal, bool finalUpdate)
{
REQUIRE_UI_THREAD();
return RV_CONTINUE;
}
// Called on the UI thread to retrieve either the simulated screen rectangle
// if |screen| is true or the view rectangle if |screen| is false. The view
// rectangle is relative to the screen coordinates. This method is only called
// if window rendering has been disabled. Return RV_CONTINUE if the rectangle
// was provided.
virtual RetVal HandleGetRect(CefRefPtr<CefBrowser> browser, bool screen,
CefRect& rect)
{
// Only called when rendering off-screen.
ASSERT(false);
return RV_CONTINUE;
}
// Called on the UI thread retrieve the translation from view coordinates to
// actual screen coordinates. This method is only called if window rendering
// has been disabled. Return RV_CONTINUE if the screen coordinates were
// provided.
virtual RetVal HandleGetScreenPoint(CefRefPtr<CefBrowser> browser,
int viewX, int viewY, int& screenX,
int& screenY)
{
// Only called when rendering off-screen.
ASSERT(false);
return RV_CONTINUE;
}
// Called on the UI thread when the browser wants to show, hide, resize or
// move the popup. If |show| is true and |rect| is zero size then the popup
// should be shown. If |show| is true and |rect| is non-zero size then |rect|
// represents the popup location in view coordinates. If |show| is false
// then the popup should be hidden. This method is only called if window
// rendering has been disabled. The return value is currently ignored.
virtual RetVal HandlePopupChange(CefRefPtr<CefBrowser> browser, bool show,
const CefRect& rect)
{
// Only called when rendering off-screen.
ASSERT(false);
return RV_CONTINUE;
}
// Called when an element should be painted. |type| indicates whether the
// element is the view or the popup. |buffer| contains the pixel data for the
// whole image. |dirtyRect| indicates the portion of the image that has been
// repainted. On Windows |buffer| will be width*height*4 bytes in size and
// represents a BGRA image with an upper-left origin. This method is only
// called if window rendering has been disabled. The return value is currently
// ignored.
virtual RetVal HandlePaint(CefRefPtr<CefBrowser> browser,
PaintElementType type, const CefRect& dirtyRect,
const void* buffer)
{
// Only called when rendering off-screen.
ASSERT(false);
return RV_CONTINUE;
}
// Called when the browser window's cursor has changed. This method is only
// called if window rendering has been disabled. The return value is currently
// ignored.
virtual RetVal HandleCursorChange(CefRefPtr<CefBrowser> browser,
CefCursorHandle cursor)
{
// Only called when rendering off-screen.
ASSERT(false);
return RV_CONTINUE;
}
// Retrieve the current navigation state flags
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; }
CefWindowHandle GetBrowserHwnd() { return m_BrowserHwnd; }
std::string GetLogFile();
void SetLastDownloadFile(const std::string& fileName);
std::string GetLastDownloadFile();
// DOM visitors will be called after the associated path is loaded.
void AddDOMVisitor(const std::string& path, CefRefPtr<CefDOMVisitor> visitor);
CefRefPtr<CefDOMVisitor> GetDOMVisitor(const std::string& path);
// 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);
protected:
virtual void SetLoading(bool isLoading);
virtual void SetNavState(bool canGoBack, bool canGoForward);
// The child browser window
CefRefPtr<CefBrowser> m_Browser;
// The main frame window handle
CefWindowHandle m_MainHwnd;
// The child browser window handle
CefWindowHandle m_BrowserHwnd;
// The edit window handle
CefWindowHandle m_EditHwnd;
// The button window handles
CefWindowHandle m_BackHwnd;
CefWindowHandle m_ForwardHwnd;
CefWindowHandle m_StopHwnd;
CefWindowHandle m_ReloadHwnd;
std::string m_LogFile;
// Support for downloading files.
CefRefPtr<DownloadListener> m_DownloadListener;
std::string m_LastDownloadFile;
typedef std::map<std::string, CefRefPtr<CefDOMVisitor> > DOMVisitorMap;
DOMVisitorMap m_DOMVisitors;
};
// Handler for popup windows that loads the request in an existing browser
// window.
class ClientPopupHandler : public ClientHandler
{
public:
ClientPopupHandler(CefRefPtr<CefBrowser> parentBrowser)
: m_ParentBrowser(parentBrowser)
{
}
virtual ~ClientPopupHandler()
{
}
virtual RetVal HandleBeforeBrowse(CefRefPtr<CefBrowser> browser,
CefRefPtr<CefFrame> frame,
CefRefPtr<CefRequest> request,
NavType navType, bool isRedirect)
{
REQUIRE_UI_THREAD();
if (m_ParentBrowser.get()) {
m_ParentBrowser->GetMainFrame()->LoadRequest(request);
browser->CloseBrowser();
m_ParentBrowser = NULL;
}
return RV_HANDLED;
}
protected:
CefRefPtr<CefBrowser> m_ParentBrowser;
};
// Returns the main browser window instance.
CefRefPtr<CefBrowser> AppGetBrowser();