2021-02-18 02:58:25 +01:00
|
|
|
// Copyright 2021 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/chrome/views/browser_platform_delegate_chrome_views.h"
|
|
|
|
|
2021-04-02 22:53:17 +02:00
|
|
|
#include "include/views/cef_window.h"
|
2023-04-12 20:34:39 +02:00
|
|
|
#include "libcef/browser/views/window_impl.h"
|
2021-04-02 22:53:17 +02:00
|
|
|
|
2023-10-05 01:46:45 +02:00
|
|
|
#include "chrome/browser/devtools/devtools_window.h"
|
2021-02-18 02:58:25 +01:00
|
|
|
#include "chrome/browser/ui/browser.h"
|
2023-10-05 01:46:45 +02:00
|
|
|
#include "components/zoom/zoom_controller.h"
|
2021-02-18 02:58:25 +01:00
|
|
|
#include "ui/views/widget/widget.h"
|
|
|
|
|
2021-04-02 22:53:17 +02:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
// Default popup window delegate implementation.
|
|
|
|
class PopupWindowDelegate : public CefWindowDelegate {
|
|
|
|
public:
|
|
|
|
explicit PopupWindowDelegate(CefRefPtr<CefBrowserView> browser_view)
|
|
|
|
: browser_view_(browser_view) {}
|
|
|
|
|
2021-12-06 21:40:25 +01:00
|
|
|
PopupWindowDelegate(const PopupWindowDelegate&) = delete;
|
|
|
|
PopupWindowDelegate& operator=(const PopupWindowDelegate&) = delete;
|
|
|
|
|
2021-04-02 22:53:17 +02:00
|
|
|
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();
|
2023-01-02 23:59:03 +01:00
|
|
|
if (browser) {
|
2021-04-02 22:53:17 +02:00
|
|
|
return browser->GetHost()->TryCloseBrowser();
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2021-04-02 22:53:17 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
CefRefPtr<CefBrowserView> browser_view_;
|
|
|
|
|
|
|
|
IMPLEMENT_REFCOUNTING(PopupWindowDelegate);
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2021-02-18 02:58:25 +01:00
|
|
|
CefBrowserPlatformDelegateChromeViews::CefBrowserPlatformDelegateChromeViews(
|
|
|
|
std::unique_ptr<CefBrowserPlatformDelegateNative> native_delegate,
|
|
|
|
CefRefPtr<CefBrowserViewImpl> browser_view)
|
2021-04-02 22:53:17 +02:00
|
|
|
: CefBrowserPlatformDelegateChrome(std::move(native_delegate)) {
|
2023-01-02 23:59:03 +01:00
|
|
|
if (browser_view) {
|
2021-04-02 22:53:17 +02:00
|
|
|
SetBrowserView(browser_view);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2021-04-02 22:53:17 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::SetBrowserView(
|
|
|
|
CefRefPtr<CefBrowserViewImpl> browser_view) {
|
|
|
|
DCHECK(!browser_view_);
|
|
|
|
DCHECK(browser_view);
|
|
|
|
browser_view_ = browser_view;
|
|
|
|
}
|
2021-02-18 02:58:25 +01:00
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::WebContentsCreated(
|
|
|
|
content::WebContents* web_contents,
|
|
|
|
bool owned) {
|
|
|
|
CefBrowserPlatformDelegateChrome::WebContentsCreated(web_contents, owned);
|
|
|
|
browser_view_->WebContentsCreated(web_contents);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::BrowserCreated(
|
|
|
|
CefBrowserHostBase* browser) {
|
|
|
|
CefBrowserPlatformDelegateChrome::BrowserCreated(browser);
|
|
|
|
browser_view_->BrowserCreated(browser, base::RepeatingClosure());
|
|
|
|
}
|
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::NotifyBrowserCreated() {
|
2023-10-05 01:46:45 +02:00
|
|
|
if (auto delegate = browser_view_->delegate()) {
|
|
|
|
delegate->OnBrowserCreated(browser_view_, browser_);
|
|
|
|
|
|
|
|
// DevTools windows hide the notification bubble by default. However, we
|
|
|
|
// don't currently have the ability to intercept WebContents creation via
|
|
|
|
// DevToolsWindow::Create(), so |show_by_default| will always be true here.
|
|
|
|
const bool show_by_default =
|
|
|
|
!DevToolsWindow::IsDevToolsWindow(web_contents_);
|
|
|
|
|
|
|
|
bool show_zoom_bubble = show_by_default;
|
|
|
|
const auto& state = browser_->settings().chrome_zoom_bubble;
|
|
|
|
if (show_by_default && state == STATE_DISABLED) {
|
|
|
|
show_zoom_bubble = false;
|
|
|
|
} else if (!show_by_default && state == STATE_ENABLED) {
|
|
|
|
show_zoom_bubble = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (show_zoom_bubble != show_by_default) {
|
|
|
|
// We may be called before TabHelpers::AttachTabHelpers(), so create
|
|
|
|
// the ZoomController if necessary.
|
|
|
|
zoom::ZoomController::CreateForWebContents(web_contents_);
|
|
|
|
zoom::ZoomController::FromWebContents(web_contents_)
|
|
|
|
->SetShowsNotificationBubble(show_zoom_bubble);
|
|
|
|
}
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2021-02-18 02:58:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::NotifyBrowserDestroyed() {
|
2023-01-02 23:59:03 +01:00
|
|
|
if (browser_view_->delegate()) {
|
2021-02-18 02:58:25 +01:00
|
|
|
browser_view_->delegate()->OnBrowserDestroyed(browser_view_, browser_);
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2021-02-18 02:58:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::BrowserDestroyed(
|
|
|
|
CefBrowserHostBase* browser) {
|
|
|
|
CefBrowserPlatformDelegateChrome::BrowserDestroyed(browser);
|
|
|
|
browser_view_->BrowserDestroyed(browser);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CefBrowserPlatformDelegateChromeViews::CloseHostWindow() {
|
|
|
|
views::Widget* widget = GetWindowWidget();
|
2023-01-02 23:59:03 +01:00
|
|
|
if (widget && !widget->IsClosed()) {
|
2021-02-18 02:58:25 +01:00
|
|
|
widget->Close();
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2021-02-18 02:58:25 +01:00
|
|
|
}
|
|
|
|
|
2022-04-08 22:48:56 +02:00
|
|
|
CefWindowHandle CefBrowserPlatformDelegateChromeViews::GetHostWindowHandle()
|
|
|
|
const {
|
|
|
|
return view_util::GetWindowHandle(GetWindowWidget());
|
|
|
|
}
|
|
|
|
|
2021-02-18 02:58:25 +01:00
|
|
|
views::Widget* CefBrowserPlatformDelegateChromeViews::GetWindowWidget() const {
|
2023-01-02 23:59:03 +01:00
|
|
|
if (browser_view_->root_view()) {
|
2021-02-18 02:58:25 +01:00
|
|
|
return browser_view_->root_view()->GetWidget();
|
2023-01-02 23:59:03 +01:00
|
|
|
}
|
2021-02-18 02:58:25 +01:00
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
CefRefPtr<CefBrowserView>
|
|
|
|
CefBrowserPlatformDelegateChromeViews::GetBrowserView() const {
|
|
|
|
return browser_view_.get();
|
|
|
|
}
|
|
|
|
|
2021-04-02 22:53:17 +02:00
|
|
|
void CefBrowserPlatformDelegateChromeViews::PopupWebContentsCreated(
|
|
|
|
const CefBrowserSettings& settings,
|
|
|
|
CefRefPtr<CefClient> client,
|
|
|
|
content::WebContents* new_web_contents,
|
|
|
|
CefBrowserPlatformDelegate* new_platform_delegate,
|
|
|
|
bool is_devtools) {
|
2022-04-11 23:29:53 +02:00
|
|
|
// Default popup handling may not be Views-hosted.
|
|
|
|
if (!new_platform_delegate->IsViewsHosted()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-04-02 22:53:17 +02:00
|
|
|
auto* new_platform_delegate_impl =
|
|
|
|
static_cast<CefBrowserPlatformDelegateChromeViews*>(
|
|
|
|
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 CefBrowserPlatformDelegateChromeViews::PopupBrowserCreated(
|
|
|
|
CefBrowserHostBase* new_browser,
|
|
|
|
bool is_devtools) {
|
2022-04-11 23:29:53 +02:00
|
|
|
// Default popup handling may not be Views-hosted.
|
|
|
|
if (!new_browser->HasView()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-04-02 22:53:17 +02:00
|
|
|
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()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-12 20:34:39 +02:00
|
|
|
void CefBrowserPlatformDelegateChromeViews::UpdateFindBarBoundingBox(
|
|
|
|
gfx::Rect* bounds) const {
|
|
|
|
if (auto* window_impl = GetWindowImpl()) {
|
|
|
|
if (window_impl->root_view()) {
|
|
|
|
window_impl->root_view()->UpdateFindBarBoundingBox(bounds);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-18 02:58:25 +01:00
|
|
|
bool CefBrowserPlatformDelegateChromeViews::IsViewsHosted() const {
|
|
|
|
return true;
|
|
|
|
}
|
2023-04-12 20:34:39 +02:00
|
|
|
|
|
|
|
CefWindowImpl* CefBrowserPlatformDelegateChromeViews::GetWindowImpl() const {
|
|
|
|
if (auto* widget = GetWindowWidget()) {
|
|
|
|
CefRefPtr<CefWindow> window = view_util::GetWindowFor(widget);
|
|
|
|
return static_cast<CefWindowImpl*>(window.get());
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|