mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2024-12-14 10:34:29 +01:00
4fbd247231
This change adds support for: - Protocol and request handling. - Loading and navigation events. - Display and focus events. - Mouse/keyboard events. - Popup browsers. - Callbacks in the renderer process. - Misc. functionality required for ceftests. This change also adds a new CefBrowserProcessHandler::GetCookieableSchemes callback for configuring global state that will be applied to all CefCookieManagers by default. This global callback is currently required by the chrome runtime because the primary ProfileImpl is created via ChromeBrowserMainParts::PreMainMessageLoopRun (CreatePrimaryProfile) before OnContextCreated can be called. ProfileImpl will use the "C:\Users\[user]\AppData\Local\CEF\User Data\Default" directory by default (on Windows). Cookies may persist in this directory when running ceftests and may need to be manually deleted if those tests fail. Remaining work includes: - Support for client-created request contexts. - Embedding the browser in a Views hierarchy (cefclient support). - TryCloseBrowser and DoClose support. - Most of the CefSettings configuration. - DevTools protocol and window control (ShowDevTools, ExecuteDevToolsMethod). - CEF-specific WebUI pages (about, license, webui-hosts). - Context menu customization (CefContextMenuHandler). - Auto resize (SetAutoResizeEnabled). - Zoom settings (SetZoomLevel). - File dialog runner (RunFileDialog). - File and JS dialog handlers (CefDialogHandler, CefJSDialogHandler). - Extension loading (LoadExtension, etc). - Plugin loading (OnBeforePluginLoad). - Widevine loading (CefRegisterWidevineCdm). - PDF and print preview does not display. - Crash reporting is untested. - Mac: Web content loads but does not display. The following ceftests are now passing when run with the "--enable-chrome-runtime" command-line flag: CorsTest.* DisplayTest.*:-DisplayTest.AutoResize DOMTest.* DraggableRegionsTest.* ImageTest.* MessageRouterTest.* NavigationTest.* ParserTest.* RequestContextTest.*Global* RequestTest.* ResourceManagerTest.* ResourceRequestHandlerTest.* ResponseTest.* SchemeHandlerTest.* ServerTest.* StreamResourceHandlerTest.* StreamTest.* StringTest.* TaskTest.* TestServerTest.* ThreadTest.* URLRequestTest.*Global* V8Test.*:-V8Test.OnUncaughtExceptionDevTools ValuesTest.* WaitableEventTest.* XmlReaderTest.* ZipReaderTest.*
296 lines
9.2 KiB
C++
296 lines
9.2 KiB
C++
// Copyright 2016 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.
|
|
|
|
#include "libcef/browser/views/browser_platform_delegate_views.h"
|
|
|
|
#include <utility>
|
|
|
|
#include "include/views/cef_window.h"
|
|
#include "libcef/browser/alloy/alloy_browser_host_impl.h"
|
|
#include "libcef/browser/views/browser_view_impl.h"
|
|
#include "libcef/browser/views/menu_runner_views.h"
|
|
|
|
#include "content/public/browser/render_view_host.h"
|
|
#include "content/public/browser/render_widget_host.h"
|
|
#include "ui/views/widget/widget.h"
|
|
|
|
namespace {
|
|
|
|
// Default popup window delegate implementation.
|
|
class PopupWindowDelegate : public CefWindowDelegate {
|
|
public:
|
|
explicit PopupWindowDelegate(CefRefPtr<CefBrowserView> browser_view)
|
|
: browser_view_(browser_view) {}
|
|
|
|
void OnWindowCreated(CefRefPtr<CefWindow> window) override {
|
|
window->AddChildView(browser_view_);
|
|
window->Show();
|
|
browser_view_->RequestFocus();
|
|
}
|
|
|
|
void OnWindowDestroyed(CefRefPtr<CefWindow> window) override {
|
|
browser_view_ = nullptr;
|
|
}
|
|
|
|
bool CanClose(CefRefPtr<CefWindow> window) override {
|
|
CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
|
|
if (browser)
|
|
return browser->GetHost()->TryCloseBrowser();
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
CefRefPtr<CefBrowserView> browser_view_;
|
|
|
|
IMPLEMENT_REFCOUNTING(PopupWindowDelegate);
|
|
DISALLOW_COPY_AND_ASSIGN(PopupWindowDelegate);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
CefBrowserPlatformDelegateViews::CefBrowserPlatformDelegateViews(
|
|
std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate,
|
|
CefRefPtr<CefBrowserViewImpl> browser_view)
|
|
: native_delegate_(std::move(native_delegate)) {
|
|
if (browser_view)
|
|
SetBrowserView(browser_view);
|
|
native_delegate_->set_windowless_handler(this);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SetBrowserView(
|
|
CefRefPtr<CefBrowserViewImpl> browser_view) {
|
|
DCHECK(!browser_view_);
|
|
DCHECK(browser_view);
|
|
browser_view_ = browser_view;
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::WebContentsCreated(
|
|
content::WebContents* web_contents,
|
|
bool owned) {
|
|
CefBrowserPlatformDelegateAlloy::WebContentsCreated(web_contents, owned);
|
|
native_delegate_->WebContentsCreated(web_contents, /*owned=*/false);
|
|
browser_view_->WebContentsCreated(web_contents);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::WebContentsDestroyed(
|
|
content::WebContents* web_contents) {
|
|
CefBrowserPlatformDelegateAlloy::WebContentsDestroyed(web_contents);
|
|
native_delegate_->WebContentsDestroyed(web_contents);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::BrowserCreated(
|
|
CefBrowserHostBase* browser) {
|
|
CefBrowserPlatformDelegateAlloy::BrowserCreated(browser);
|
|
|
|
native_delegate_->BrowserCreated(browser);
|
|
browser_view_->BrowserCreated(browser, GetBoundsChangedCallback());
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::NotifyBrowserCreated() {
|
|
DCHECK(browser_view_);
|
|
DCHECK(browser_);
|
|
if (browser_view_->delegate())
|
|
browser_view_->delegate()->OnBrowserCreated(browser_view_, browser_);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::NotifyBrowserDestroyed() {
|
|
DCHECK(browser_view_);
|
|
DCHECK(browser_);
|
|
if (browser_view_->delegate())
|
|
browser_view_->delegate()->OnBrowserDestroyed(browser_view_, browser_);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::BrowserDestroyed(
|
|
CefBrowserHostBase* browser) {
|
|
CefBrowserPlatformDelegateAlloy::BrowserDestroyed(browser);
|
|
|
|
browser_view_->BrowserDestroyed(browser);
|
|
browser_view_ = nullptr;
|
|
native_delegate_->BrowserDestroyed(browser);
|
|
}
|
|
|
|
bool CefBrowserPlatformDelegateViews::CreateHostWindow() {
|
|
// Nothing to do here.
|
|
return true;
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::CloseHostWindow() {
|
|
views::Widget* widget = GetWindowWidget();
|
|
if (widget && !widget->IsClosed())
|
|
widget->Close();
|
|
}
|
|
|
|
CefWindowHandle CefBrowserPlatformDelegateViews::GetHostWindowHandle() const {
|
|
return view_util::GetWindowHandle(GetWindowWidget());
|
|
}
|
|
|
|
views::Widget* CefBrowserPlatformDelegateViews::GetWindowWidget() const {
|
|
if (browser_view_->root_view())
|
|
return browser_view_->root_view()->GetWidget();
|
|
return nullptr;
|
|
}
|
|
|
|
CefRefPtr<CefBrowserView> CefBrowserPlatformDelegateViews::GetBrowserView()
|
|
const {
|
|
return browser_view_.get();
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::PopupWebContentsCreated(
|
|
const CefBrowserSettings& settings,
|
|
CefRefPtr<CefClient> client,
|
|
content::WebContents* new_web_contents,
|
|
CefBrowserPlatformDelegate* new_platform_delegate,
|
|
bool is_devtools) {
|
|
DCHECK(new_platform_delegate->IsViewsHosted());
|
|
CefBrowserPlatformDelegateViews* new_platform_delegate_impl =
|
|
static_cast<CefBrowserPlatformDelegateViews*>(new_platform_delegate);
|
|
|
|
CefRefPtr<CefBrowserViewDelegate> new_delegate;
|
|
if (browser_view_->delegate()) {
|
|
new_delegate = browser_view_->delegate()->GetDelegateForPopupBrowserView(
|
|
browser_view_.get(), settings, client, is_devtools);
|
|
}
|
|
|
|
// Create a new BrowserView for the popup.
|
|
CefRefPtr<CefBrowserViewImpl> new_browser_view =
|
|
CefBrowserViewImpl::CreateForPopup(settings, new_delegate);
|
|
|
|
// Associate the PlatformDelegate with the new BrowserView.
|
|
new_platform_delegate_impl->SetBrowserView(new_browser_view);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::PopupBrowserCreated(
|
|
CefBrowserHostBase* new_browser,
|
|
bool is_devtools) {
|
|
CefRefPtr<CefBrowserView> new_browser_view =
|
|
CefBrowserView::GetForBrowser(new_browser);
|
|
DCHECK(new_browser_view);
|
|
|
|
bool popup_handled = false;
|
|
if (browser_view_->delegate()) {
|
|
popup_handled = browser_view_->delegate()->OnPopupBrowserViewCreated(
|
|
browser_view_.get(), new_browser_view.get(), is_devtools);
|
|
}
|
|
|
|
if (!popup_handled) {
|
|
CefWindow::CreateTopLevelWindow(
|
|
new PopupWindowDelegate(new_browser_view.get()));
|
|
}
|
|
}
|
|
|
|
SkColor CefBrowserPlatformDelegateViews::GetBackgroundColor() const {
|
|
return native_delegate_->GetBackgroundColor();
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::WasResized() {
|
|
native_delegate_->WasResized();
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SendKeyEvent(const CefKeyEvent& event) {
|
|
native_delegate_->SendKeyEvent(event);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SendMouseClickEvent(
|
|
const CefMouseEvent& event,
|
|
CefBrowserHost::MouseButtonType type,
|
|
bool mouseUp,
|
|
int clickCount) {
|
|
native_delegate_->SendMouseClickEvent(event, type, mouseUp, clickCount);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SendMouseMoveEvent(
|
|
const CefMouseEvent& event,
|
|
bool mouseLeave) {
|
|
native_delegate_->SendMouseMoveEvent(event, mouseLeave);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SendMouseWheelEvent(
|
|
const CefMouseEvent& event,
|
|
int deltaX,
|
|
int deltaY) {
|
|
native_delegate_->SendMouseWheelEvent(event, deltaX, deltaY);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SendTouchEvent(
|
|
const CefTouchEvent& event) {
|
|
native_delegate_->SendTouchEvent(event);
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::SendFocusEvent(bool setFocus) {
|
|
// Will result in a call to WebContents::Focus().
|
|
if (setFocus && browser_view_->root_view())
|
|
browser_view_->root_view()->RequestFocus();
|
|
}
|
|
|
|
gfx::Point CefBrowserPlatformDelegateViews::GetScreenPoint(
|
|
const gfx::Point& view_pt) const {
|
|
if (!browser_view_->root_view())
|
|
return view_pt;
|
|
|
|
gfx::Point screen_point = view_pt;
|
|
view_util::ConvertPointToScreen(browser_view_->root_view(), &screen_point,
|
|
true);
|
|
return screen_point;
|
|
}
|
|
|
|
void CefBrowserPlatformDelegateViews::ViewText(const std::string& text) {
|
|
native_delegate_->ViewText(text);
|
|
}
|
|
|
|
bool CefBrowserPlatformDelegateViews::HandleKeyboardEvent(
|
|
const content::NativeWebKeyboardEvent& event) {
|
|
// The BrowserView will handle accelerators.
|
|
return browser_view_->HandleKeyboardEvent(event);
|
|
}
|
|
|
|
CefEventHandle CefBrowserPlatformDelegateViews::GetEventHandle(
|
|
const content::NativeWebKeyboardEvent& event) const {
|
|
return native_delegate_->GetEventHandle(event);
|
|
}
|
|
|
|
std::unique_ptr<CefFileDialogRunner>
|
|
CefBrowserPlatformDelegateViews::CreateFileDialogRunner() {
|
|
return native_delegate_->CreateFileDialogRunner();
|
|
}
|
|
|
|
std::unique_ptr<CefJavaScriptDialogRunner>
|
|
CefBrowserPlatformDelegateViews::CreateJavaScriptDialogRunner() {
|
|
return native_delegate_->CreateJavaScriptDialogRunner();
|
|
}
|
|
|
|
std::unique_ptr<CefMenuRunner>
|
|
CefBrowserPlatformDelegateViews::CreateMenuRunner() {
|
|
return base::WrapUnique(new CefMenuRunnerViews(browser_view_.get()));
|
|
}
|
|
|
|
bool CefBrowserPlatformDelegateViews::IsViewsHosted() const {
|
|
return true;
|
|
}
|
|
|
|
gfx::Point CefBrowserPlatformDelegateViews::GetDialogPosition(
|
|
const gfx::Size& size) {
|
|
const gfx::Rect& bounds = browser_view_->root_view()->GetBoundsInScreen();
|
|
|
|
// Offset relative to the top-level content view.
|
|
gfx::Point offset = bounds.origin();
|
|
view_util::ConvertPointFromScreen(
|
|
browser_view_->root_view()->GetWidget()->GetRootView(), &offset, false);
|
|
|
|
return gfx::Point(offset.x() + (bounds.width() - size.width()) / 2,
|
|
offset.y() + (bounds.height() - size.height()) / 2);
|
|
}
|
|
|
|
gfx::Size CefBrowserPlatformDelegateViews::GetMaximumDialogSize() {
|
|
return browser_view_->root_view()->GetBoundsInScreen().size();
|
|
}
|
|
|
|
CefWindowHandle CefBrowserPlatformDelegateViews::GetParentWindowHandle() const {
|
|
return GetHostWindowHandle();
|
|
}
|
|
|
|
gfx::Point CefBrowserPlatformDelegateViews::GetParentScreenPoint(
|
|
const gfx::Point& view) const {
|
|
return GetScreenPoint(view);
|
|
}
|