aphrody-labs/cef
1
0 Fork 0
mirror of https://github.com/aphrody-labs/cef.git synced 2026-10-13 21:07:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
cd89341bfe7eb5e856e98c8cac9b29fe5f77f926
cef/patch/patches/chrome_browser_browser.patch
T
Marshall Greenblatt cd89341bfe chrome: Preserve request context for Inspect Element (fixes #4168) 
Keep CEF-created unique OTR profiles when resolving the DevTools
profile so Inspect Element does not create the popup with the parent
profile. Add coverage for a non-global request context and verify that
the DevTools popup shares it.
2026-08-19 18:05:13 -04:00

1002 lines
40 KiB
Diff
Raw Blame History

diff --git chrome/browser/browser_about_handler.cc chrome/browser/browser_about_handler.cc
index 08949a69415dfa9f836e00929a34330a34546ce2..e417f50fa68e274b80c0d45bdaa45c7b22fd6dcd 100644
--- chrome/browser/browser_about_handler.cc
+++ chrome/browser/browser_about_handler.cc
@@ -25,6 +25,10 @@
namespace {
+bool IsChromeIgnoreUrl(const std::string& spec) {
+ return base::EqualsCaseInsensitiveASCII(spec, "chrome://ignore/");
+}
+
bool IsNonNavigationAboutUrl(const GURL& url) {
if (!url.is_valid()) {
return false;
@@ -32,8 +36,8 @@ bool IsNonNavigationAboutUrl(const GURL& url) {
const std::string spec(url.spec());
return base::EqualsCaseInsensitiveASCII(spec, chrome::kChromeUIRestartURL) ||
- base::EqualsCaseInsensitiveASCII(spec, chrome::kChromeUIQuitURL);
- ;
+ base::EqualsCaseInsensitiveASCII(spec, chrome::kChromeUIQuitURL) ||
+ IsChromeIgnoreUrl(spec);
}
} // namespace
@@ -102,5 +106,8 @@ bool HandleNonNavigationAboutURL(const GURL& url,
FROM_HERE, base::BindOnce(&chrome::AttemptExit));
return true;
}
+ if (IsChromeIgnoreUrl(spec)) {
+ return true;
+ }
NOTREACHED();
}
diff --git chrome/browser/devtools/devtools_window.cc chrome/browser/devtools/devtools_window.cc
index 9d28b02fa09bf331ed9b381ba25b56f0a30ec365..5ffa364977080aaab9819d789e73544334410271 100644
--- chrome/browser/devtools/devtools_window.cc
+++ chrome/browser/devtools/devtools_window.cc
@@ -854,6 +854,12 @@ Profile* DevToolsWindow::GetProfileForDevToolsWindow(
if (profile->IsPrimaryOTRProfile() || profile->IsDevToolsOTRProfile()) {
return profile;
}
+#if BUILDFLAG(ENABLE_CEF)
+ if (profile->IsOffTheRecord() &&
+ profile->GetOTRProfileID().IsUniqueForCEF()) {
+ return profile;
+ }
+#endif
return profile->GetOriginalProfile();
}
@@ -1380,6 +1386,14 @@ DevToolsWindow* DevToolsWindow::Create(
if (!devtools_ui_controller || !devtools_ui_controller->CanDockDevtools()) {
can_dock = false;
}
+
+#if BUILDFLAG(ENABLE_CEF)
+ if (can_dock && browser &&
+ browser->GetBrowserForMigrationOnly()->cef_delegate()) {
+ // Don't dock DevTools for CEF-managed browsers.
+ can_dock = false;
+ }
+#endif
}
#endif // !BUILDFLAG(IS_ANDROID)
@@ -1844,7 +1858,9 @@ void DevToolsWindow::OpenInNewTab(const GURL& url) {
/*navigation_handle_callback=*/{})) {
#if BUILDFLAG(IS_ANDROID)
NOTIMPLEMENTED();
-#else
+#elif !BUILDFLAG(ENABLE_CEF)
+ // Remove default behavior when CEF handles the open via OnOpenURLFromTab.
+ // See CEF issue #3735.
chrome::ScopedTabbedBrowserDisplayer displayer(profile_);
chrome::AddSelectedTabWithURL(displayer.browser_window_interface(),
fixed_url, ui::PAGE_TRANSITION_LINK);
@@ -2050,12 +2066,31 @@ void DevToolsWindow::CreateDevToolsBrowser() {
Browser::CreationStatus::kOk) {
return;
}
- browser_ =
- Browser::Create(Browser::CreateParams::CreateForDevTools(profile_));
- browser_->GetTabStripModel()->AddWebContents(
- OwnedMainWebContents::TakeWebContents(
- std::move(owned_main_web_contents_)),
- -1, ui::PAGE_TRANSITION_AUTO_TOPLEVEL, AddTabTypes::ADD_ACTIVE);
+
+ auto* inspected_web_contents = GetInspectedWebContents();
+ BrowserWindowInterface* opener = nullptr;
+ if (inspected_web_contents) {
+ opener = GlobalBrowserCollection::GetInstance()->FindBrowserWithTab(inspected_web_contents);
+ }
+ auto devtools_contents = OwnedMainWebContents::TakeWebContents(
+ std::move(owned_main_web_contents_));
+
+#if BUILDFLAG(ENABLE_CEF)
+ // If a Browser is created, it will take ownership of |devtools_contents|.
+ browser_ = cef::BrowserDelegate::CreateDevToolsBrowser(
+ profile_, opener ? opener->GetBrowserForMigrationOnly() : nullptr,
+ inspected_web_contents, devtools_contents);
+#endif
+
+ if (!browser_) {
+ auto create_params = Browser::CreateParams::CreateForDevTools(profile_);
+ create_params.opener = opener;
+
+ browser_ = Browser::Create(std::move(create_params));
+ browser_->GetTabStripModel()->AddWebContents(
+ std::move(devtools_contents),
+ -1, ui::PAGE_TRANSITION_AUTO_TOPLEVEL, AddTabTypes::ADD_ACTIVE);
+ }
#endif
OverrideAndSyncDevToolsRendererPrefs();
}
diff --git chrome/browser/ui/BUILD.gn chrome/browser/ui/BUILD.gn
index 8c8fc32b01b6c50bd67ea0efb7efddf135845e1b..9a57dd37072c0de8fd8042d0b040a06ffae735aa 100644
--- chrome/browser/ui/BUILD.gn
+++ chrome/browser/ui/BUILD.gn
@@ -7,6 +7,7 @@ import("//build/config/compiler/compiler.gni")
import("//build/config/features.gni")
import("//build/config/ozone.gni")
import("//build/config/ui.gni")
+import("//cef/libcef/features/features.gni")
import("//chrome/browser/buildflags.gni")
import("//chrome/common/features.gni")
import("//components/captive_portal/core/features.gni")
@@ -424,6 +425,10 @@ static_library("ui") {
"//build/config/compiler:wexit_time_destructors",
]
+ if (enable_cef) {
+ configs += [ "//cef/libcef/features:config" ]
+ }
+
public_deps = [
# WARNING WARNING WARNING
# New dependencies outside of //chrome/browser should be added to
@@ -481,6 +486,7 @@ static_library("ui") {
"//build/config/linux/dbus:buildflags",
"//build/util:chromium_git_revision",
"//cc/paint",
+ "//cef/libcef/features:buildflags",
"//chrome:resources",
"//chrome:strings",
"//chrome/app:chrome_dll_resources",
@@ -1057,6 +1063,13 @@ static_library("ui") {
]
}
+ if (enable_cef) {
+ deps += [
+ "//cef:cef_resources",
+ "//cef/libcef/features:deps",
+ ]
+ }
+
if (!is_android) {
deps += [
"//chrome/browser/ui/infobars",
@@ -5154,6 +5167,7 @@ static_library("ui") {
"//chrome/browser/printing",
"//chrome/browser/printing:impl",
"//components/printing/browser",
+ "//components/printing/common:mojo_interfaces",
"//printing",
]
allow_circular_includes_from += [ "//chrome/browser/printing:impl" ]
diff --git chrome/browser/ui/browser.cc chrome/browser/ui/browser.cc
index 47c68b1f47caa9ff748bfe2f17374699a9ec410d..4f96a895c7e480162dd73356e20b8bd9df255f14 100644
--- chrome/browser/ui/browser.cc
+++ chrome/browser/ui/browser.cc
@@ -306,6 +306,25 @@
#include "chrome/browser/ui/overscroll_pref_manager.h"
#endif // defined(USE_AURA)
+#if BUILDFLAG(ENABLE_CEF)
+#define CALL_CEF_DELEGATE(name, ...) \
+ if (cef_browser_delegate_) { \
+ cef_browser_delegate_->name(__VA_ARGS__); \
+ }
+#define CALL_CEF_DELEGATE_RETURN(name, ...) \
+ if (cef_browser_delegate_) { \
+ return cef_browser_delegate_->name(__VA_ARGS__); \
+ }
+#define CALL_CEF_DELEGATE_RESULT(name, result, ...) \
+ if (cef_browser_delegate_) { \
+ result = cef_browser_delegate_->name(__VA_ARGS__); \
+ }
+#else // !BUILDFLAG(ENABLE_CEF)
+#define CALL_CEF_DELEGATE(name, ...)
+#define CALL_CEF_DELEGATE_RETURN(name, ...)
+#define CALL_CEF_DELEGATE_RESULT(name, result, ...)
+#endif
+
using base::UserMetricsAction;
using content::GlobalRenderFrameHostId;
using content::NavigationController;
@@ -493,6 +512,10 @@ Browser::Browser(const CreateParams& params)
: type_(params.type),
profile_(params.profile),
window_(nullptr),
+#if BUILDFLAG(ENABLE_CEF)
+ cef_browser_delegate_(
+ cef::BrowserDelegate::Create(this, params.cef_params, params.opener)),
+#endif
tab_strip_model_delegate_(
std::make_unique<chrome::BrowserTabStripModelDelegate>(this)),
tab_strip_model_(std::make_unique<TabStripModel>(
@@ -549,9 +572,6 @@ Browser::Browser(const CreateParams& params)
}
#endif // BUILDFLAG(IS_OZONE)
- if (params.window) {
- CHECK_IS_TEST() << "Browser::CreateParams::window is a test-only param";
- }
window_ =
params.window
? std::unique_ptr<BrowserWindow, BrowserWindowDeleter>(params.window)
@@ -567,9 +587,19 @@ Browser::Browser(const CreateParams& params)
session_service->WindowOpened(this);
}
- // Initialize the browser features that rely on the browser window now that it
- // is initialized.
- features_->InitPostWindowConstruction(this);
+ const bool views_hosted =
+#if BUILDFLAG(ENABLE_CEF)
+ cef_delegate() && cef_delegate()->IsViewsHosted();
+#else
+ false;
+#endif
+
+ if (!views_hosted) {
+ // Initialize the browser features that rely on the browser window now that
+ // it is initialized. This will instead be called from
+ // BrowserView::AddedToWidget() for CEF Views-hosted windows.
+ features_->InitPostWindowConstruction(this);
+ }
// All initialization is complete; after this point, the browser should be on
// the browser list until it is marked for destruction.
@@ -822,6 +852,10 @@ BrowserWindowInterface::Type Browser::GetType() const {
return type_;
}
+bool Browser::IsNormalBrowser() const {
+ return BrowserWindowFeatures::IsNormalBrowser(this);
+}
+
std::vector<tabs::TabInterface*> Browser::GetAllTabInterfaces() {
std::vector<tabs::TabInterface*> results;
results.reserve(tab_strip_model_->count());
@@ -936,6 +970,8 @@ void Browser::WindowFullscreenStateChanged() {
GetCommandController()->FullscreenStateChanged();
BookmarkBarController::From(this)->UpdateBookmarkBarState(
BookmarkBarController::StateChangeReason::kToggleFullscreen);
+
+ CALL_CEF_DELEGATE(WindowFullscreenStateChanged);
}
void Browser::FullscreenTopUIStateChanged() {
@@ -954,6 +990,14 @@ void Browser::OnFindBarVisibilityChanged() {
// Browser, Assorted browser commands:
bool Browser::SupportsWindowFeature(WindowFeature feature) const {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_delegate()) {
+ if (auto value =
+ cef_delegate()->SupportsWindowFeature(static_cast<int>(feature))) {
+ return *value;
+ }
+ }
+#endif
return WindowFeatureController::From(this)->SupportsWindowFeature(feature);
}
@@ -1139,12 +1183,28 @@ void Browser::HandleDragEnded() {
content::KeyboardEventProcessingResult Browser::PreHandleKeyboardEvent(
content::WebContents* source,
const NativeWebKeyboardEvent& event) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_) {
+ auto result = cef_browser_delegate_->PreHandleKeyboardEvent(source, event);
+ if (result != content::KeyboardEventProcessingResult::NOT_HANDLED) {
+ return result;
+ }
+ }
+#endif
+
return BrowserWebContentsDelegate::From(this)->PreHandleKeyboardEvent(source,
event);
}
bool Browser::HandleKeyboardEvent(content::WebContents* source,
const NativeWebKeyboardEvent& event) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_ &&
+ cef_browser_delegate_->HandleKeyboardEvent(source, event)) {
+ return true;
+ }
+#endif
+
return BrowserWebContentsDelegate::From(this)->HandleKeyboardEvent(source,
event);
}
@@ -1204,9 +1264,14 @@ bool Browser::IsBackForwardCacheSupported(content::WebContents& web_contents) {
content::PreloadingEligibility Browser::IsPrerender2Supported(
content::WebContents& web_contents,
content::PreloadingTriggerType trigger_type) {
+#if BUILDFLAG(ENABLE_CEF)
+ // Prerender is not supported in CEF. See issue #3664.
+ return content::PreloadingEligibility::kPreloadingDisabled;
+#else
Profile* profile =
Profile::FromBrowserContext(web_contents.GetBrowserContext());
return prefetch::IsSomePreloadingEnabled(*profile->GetPrefs());
+#endif
}
bool Browser::ShouldShowStaleContentOnEviction(content::WebContents* source) {
@@ -1280,6 +1345,14 @@ WebContents* Browser::OpenURLFromTab(
}
}
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_ &&
+ !cef_browser_delegate_->OpenURLFromTabEx(source, params,
+ navigation_handle_callback)) {
+ return nullptr;
+ }
+#endif
+
NavigateParams nav_params(this, params.url, params.transition);
nav_params.FillNavigateParamsFromOpenURLParams(params);
nav_params.source_contents = source;
@@ -1475,6 +1548,8 @@ void Browser::LoadingStateChanged(WebContents* source,
bool should_show_loading_ui) {
ScheduleUIUpdate(source, content::INVALIDATE_TYPE_LOAD);
UpdateWindowForLoadingStateChanged(source, should_show_loading_ui);
+
+ CALL_CEF_DELEGATE(LoadingStateChanged, source, should_show_loading_ui);
}
void Browser::CloseContents(WebContents* source) {
@@ -1484,6 +1559,13 @@ void Browser::CloseContents(WebContents* source) {
}
void Browser::SetContentsBounds(WebContents* source, const gfx::Rect& bounds) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_ &&
+ cef_browser_delegate_->SetContentsBoundsEx(source, bounds)) {
+ return;
+ }
+#endif
+
if (is_type_normal()) {
return;
}
@@ -1504,6 +1586,8 @@ void Browser::SetContentsBounds(WebContents* source, const gfx::Rect& bounds) {
}
void Browser::UpdateTargetURL(WebContents* source, const GURL& url) {
+ CALL_CEF_DELEGATE(UpdateTargetURL, source, url);
+
std::vector<StatusBubble*> status_bubbles = GetStatusBubbles();
for (StatusBubble* status_bubble : status_bubbles) {
StatusBubbleViews* status_bubble_views =
@@ -1550,15 +1634,31 @@ void Browser::ContentsZoomChange(bool zoom_in) {
}
bool Browser::TakeFocus(content::WebContents* source, bool reverse) {
+ CALL_CEF_DELEGATE_RETURN(TakeFocus, source, reverse);
return false;
}
+void Browser::CanDownload(const GURL& url,
+ const std::string& request_method,
+ base::OnceCallback<void(bool)> callback) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_) {
+ cef_browser_delegate_->CanDownload(url, request_method,
+ std::move(callback));
+ return;
+ }
+#endif
+ std::move(callback).Run(true);
+}
+
bool Browser::DidAddMessageToConsole(
content::WebContents* source,
blink::mojom::ConsoleMessageLevel log_level,
const std::u16string& message,
int32_t line_no,
const std::u16string& source_id) {
+ CALL_CEF_DELEGATE_RETURN(DidAddMessageToConsole, source, log_level, message,
+ line_no, source_id);
static bool is_headless_mode = headless::IsHeadlessMode();
if (is_headless_mode) {
const bool is_builtin_component = !!source->GetWebUI();
@@ -1716,12 +1816,23 @@ void Browser::WebContentsCreated(WebContents* source_contents,
// to track `new_contents` after it is added to its TabModel this override can
// be removed.
CreateSessionServiceTabHelper(new_contents);
+
+ CALL_CEF_DELEGATE(WebContentsCreated, source_contents, opener_id, frame_name,
+ target_url, new_contents);
}
void Browser::RendererUnresponsive(
WebContents* source,
content::RenderWidgetHost* render_widget_host,
base::RepeatingClosure hang_monitor_restarter) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_ &&
+ cef_browser_delegate_->RendererUnresponsiveEx(source, render_widget_host,
+ hang_monitor_restarter)) {
+ return;
+ }
+#endif
+
// Don't show the page hung dialog when a HTML popup hangs because
// the dialog will take the focus and immediately close the popup.
RenderWidgetHostView* view = render_widget_host->GetView();
@@ -1734,6 +1845,13 @@ void Browser::RendererUnresponsive(
void Browser::RendererResponsive(
WebContents* source,
content::RenderWidgetHost* render_widget_host) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_ &&
+ cef_browser_delegate_->RendererResponsiveEx(source, render_widget_host)) {
+ return;
+ }
+#endif
+
RenderWidgetHostView* view = render_widget_host->GetView();
if (view && !render_widget_host->GetView()->IsHTMLFormPopup()) {
TabDialogs::FromWebContents(source)->HideHungRendererDialog(
@@ -1743,6 +1861,15 @@ void Browser::RendererResponsive(
content::JavaScriptDialogManager* Browser::GetJavaScriptDialogManager(
WebContents* source) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_) {
+ auto* cef_js_dialog_manager =
+ cef_browser_delegate_->GetJavaScriptDialogManager(source);
+ if (cef_js_dialog_manager) {
+ return cef_js_dialog_manager;
+ }
+ }
+#endif
return javascript_dialogs::TabModalDialogManager::FromWebContents(source);
}
@@ -1769,6 +1896,11 @@ void Browser::DraggableRegionsChanged(
web_app::AppBrowserController::From(this)) {
app_browser_controller->DraggableRegionsChanged(regions, contents);
}
+#if BUILDFLAG(ENABLE_CEF)
+ else if (cef_delegate()) {
+ cef_delegate()->DraggableRegionsChanged(regions, contents);
+ }
+#endif
}
std::vector<blink::mojom::RelatedApplicationPtr>
@@ -1894,6 +2026,8 @@ void Browser::EnterFullscreenModeForTab(
->fullscreen_controller()
->EnterFullscreenModeForTab(requesting_frame,
FullscreenTabParams{options.display_id});
+
+ CALL_CEF_DELEGATE(EnterFullscreenModeForTab, requesting_frame, options);
}
void Browser::ExitFullscreenModeForTab(WebContents* web_contents) {
@@ -1901,6 +2035,8 @@ void Browser::ExitFullscreenModeForTab(WebContents* web_contents) {
->exclusive_access_manager()
->fullscreen_controller()
->ExitFullscreenModeForTab(web_contents);
+
+ CALL_CEF_DELEGATE(ExitFullscreenModeForTab, web_contents);
}
bool Browser::IsFullscreenForTabOrPending(const WebContents* web_contents) {
@@ -2084,6 +2220,18 @@ void Browser::FindReply(WebContents* web_contents,
find_tab_helper->HandleFindReply(request_id, number_of_matches,
selection_rect, active_match_ordinal,
final_update);
+ CALL_CEF_DELEGATE(FindReply, web_contents, request_id, number_of_matches,
+ selection_rect, active_match_ordinal, final_update);
+}
+
+void Browser::UpdatePreferredSize(WebContents* source,
+ const gfx::Size& pref_size) {
+ CALL_CEF_DELEGATE(UpdatePreferredSize, source, pref_size);
+}
+
+void Browser::ResizeDueToAutoResize(WebContents* source,
+ const gfx::Size& new_size) {
+ CALL_CEF_DELEGATE(ResizeDueToAutoResize, source, new_size);
}
void Browser::RequestPointerLock(WebContents* web_contents,
@@ -2122,6 +2270,16 @@ void Browser::RequestMediaAccessPermission(
content::WebContents* web_contents,
const content::MediaStreamRequest& request,
content::MediaResponseCallback callback) {
+#if BUILDFLAG(ENABLE_CEF)
+ if (cef_browser_delegate_) {
+ callback = cef_browser_delegate_->RequestMediaAccessPermissionEx(
+ web_contents, request, std::move(callback));
+ if (callback.is_null()) {
+ return;
+ }
+ }
+#endif
+
const extensions::Extension* extension =
GetExtensionForOrigin(profile_, request.security_origin);
MediaCaptureDevicesDispatcher::GetInstance()->ProcessMediaAccessRequest(
@@ -2613,9 +2771,11 @@ void Browser::RemoveScheduledUpdatesFor(WebContents* contents) {
// Browser, Getters for UI (private):
std::vector<StatusBubble*> Browser::GetStatusBubbles() {
+ bool show_by_default = true;
+
// For kiosk and exclusive app mode we want to always hide the status bubble.
if (IsRunningInAppMode()) {
- return {};
+ show_by_default = false;
}
// We hide the status bar for web apps windows as this matches native
@@ -2625,6 +2785,12 @@ std::vector<StatusBubble*> Browser::GetStatusBubbles() {
web_app::AppBrowserController::From(this);
if (app_browser_controller &&
!app_browser_controller->HasMinimalUiButtons()) {
+ show_by_default = false;
+ }
+
+ bool show = show_by_default;
+ CALL_CEF_DELEGATE_RESULT(ShowStatusBubble, show, show_by_default);
+ if (!show) {
return {};
}
@@ -2660,6 +2826,8 @@ void Browser::SetAsDelegate(WebContents* web_contents, bool set_delegate) {
} else {
web_contents_collection_.StopObserving(web_contents);
}
+
+ CALL_CEF_DELEGATE(SetAsDelegate, web_contents, set_delegate);
}
void Browser::TabDetachedAtImpl(content::WebContents* contents,
diff --git chrome/browser/ui/browser.h chrome/browser/ui/browser.h
index 324951ceb77a20ed5eb85a736cd087166218b077..1695077bab63cd098c29cc468860fe5aaebca890 100644
--- chrome/browser/ui/browser.h
+++ chrome/browser/ui/browser.h
@@ -24,6 +24,7 @@
#include "base/timer/elapsed_timer.h"
#include "base/types/expected.h"
#include "build/build_config.h"
+#include "cef/libcef/features/features.h"
#include "chrome/browser/tab_contents/web_contents_collection.h"
#include "chrome/browser/ui/bookmarks/bookmark_bar.h"
#include "chrome/browser/ui/bookmarks/bookmark_bar_controller.h"
@@ -53,6 +54,10 @@
#include "ui/gfx/geometry/rect.h"
#include "url/origin.h"
+#if BUILDFLAG(ENABLE_CEF)
+#include "cef/libcef/browser/chrome/browser_delegate.h"
+#endif
+
#if BUILDFLAG(IS_ANDROID)
#error This file should only be included on desktop.
#endif
@@ -269,6 +274,15 @@ class Browser : public TabStripModelObserver,
// Specifies the width for the uncollapsed Vertical Tab Strip.
std::optional<int> vertical_tab_strip_uncollapsed_width;
+#if BUILDFLAG(ENABLE_CEF)
+ // Opaque CEF-specific configuration. Will be propagated to new Browsers.
+ scoped_refptr<cef::BrowserDelegate::CreateParams> cef_params;
+
+ // Specify the Browser that is opening this popup.
+ // Currently only used with TYPE_PICTURE_IN_PICTURE and TYPE_DEVTOOLS.
+ raw_ptr<BrowserWindowInterface, DanglingUntriaged> opener = nullptr;
+#endif
+
private:
friend class Browser;
friend class WindowSizerChromeOSTest;
@@ -327,6 +341,16 @@ class Browser : public TabStripModelObserver,
update_ui_immediately_for_testing_ = true;
}
+ // Return true if CEF will expose the toolbar to the client. This value is
+ // used to selectively enable toolbar behaviors such as command processing
+ // and omnibox focus without also including the toolbar in BrowserView layout
+ // calculations.
+ void set_toolbar_overridden(bool val) { toolbar_overridden_ = val; }
+ bool toolbar_overridden() const { return toolbar_overridden_; }
+
+ // Used when the BrowserWindow will outlive this Browser.
+ void ReleaseBrowserWindow() { window_.release(); }
+
// Accessors ////////////////////////////////////////////////////////////////
Type type() const { return type_; }
@@ -349,6 +373,12 @@ class Browser : public TabStripModelObserver,
return features_.get();
}
+#if BUILDFLAG(ENABLE_CEF)
+ cef::BrowserDelegate* cef_delegate() const {
+ return cef_browser_delegate_.get();
+ }
+#endif
+
base::WeakPtr<Browser> AsWeakPtr();
base::WeakPtr<const Browser> AsWeakPtr() const;
@@ -527,6 +557,7 @@ class Browser : public TabStripModelObserver,
DidBecomeInactiveCallback callback) override;
BrowserActions* GetActions() override;
Type GetType() const override;
+ bool IsNormalBrowser() const override;
std::vector<tabs::TabInterface*> GetAllTabInterfaces() override;
Browser* GetBrowserForMigrationOnly() override;
const Browser* GetBrowserForMigrationOnly() const override;
@@ -615,6 +646,9 @@ class Browser : public TabStripModelObserver,
const ui::Event& event) override;
void ContentsZoomChange(bool zoom_in) override;
bool TakeFocus(content::WebContents* source, bool reverse) override;
+ void CanDownload(const GURL& url,
+ const std::string& request_method,
+ base::OnceCallback<void(bool)> callback) override;
bool DidAddMessageToConsole(content::WebContents* source,
blink::mojom::ConsoleMessageLevel log_level,
const std::u16string& message,
@@ -705,6 +739,10 @@ class Browser : public TabStripModelObserver,
const gfx::Rect& selection_rect,
int active_match_ordinal,
bool final_update) override;
+ void UpdatePreferredSize(content::WebContents* source,
+ const gfx::Size& pref_size) override;
+ void ResizeDueToAutoResize(content::WebContents* source,
+ const gfx::Size& new_size) override;
void RequestPointerLock(content::WebContents* web_contents,
bool user_gesture,
bool last_unlocked_by_target) override;
@@ -889,6 +927,12 @@ class Browser : public TabStripModelObserver,
// The active state of this browser.
bool is_active_ = false;
+#if BUILDFLAG(ENABLE_CEF)
+ std::unique_ptr<cef::BrowserDelegate> cef_browser_delegate_;
+#endif
+
+ bool toolbar_overridden_ = false;
+
std::unique_ptr<TabStripModelDelegate> const tab_strip_model_delegate_;
std::unique_ptr<TabStripModel> const tab_strip_model_;
diff --git chrome/browser/ui/browser_manager_service.cc chrome/browser/ui/browser_manager_service.cc
index 3a9c66792158d0a7baba089287029a5eae346544..edda939d9799fef16b1c828829e7f23ee727e9f1 100644
--- chrome/browser/ui/browser_manager_service.cc
+++ chrome/browser/ui/browser_manager_service.cc
@@ -128,20 +128,28 @@ void BrowserManagerService::DeleteBrowser(Browser* removed_browser) {
//
// TODO(crbug.com/40159237): Use ScopedProfileKeepAlive for Incognito too,
// instead of separate logic for Incognito and regular profiles.
- target_browser_and_subscriptions->browser.reset();
- if (browsers_and_subscriptions_.empty() && profile_->IsIncognitoProfile() &&
- !profile_->IsSystemProfile()) {
+ // Capture state from `this` before destroying the Browser. The destruction
+ // chain may release the last reference keeping the Profile alive (e.g. via
+ // CEF's CefRequestContext release for OTR profiles), which triggers keyed
+ // service shutdown and destroys `this`. Do not access members after the
+ // reset below.
+ const bool is_last_browser = browsers_and_subscriptions_.empty();
+ base::WeakPtr<Profile> weak_profile = profile_->GetWeakPtr();
+ target_browser_and_subscriptions.reset();
+ if (is_last_browser && weak_profile &&
+ weak_profile->IsIncognitoProfile() &&
+ !weak_profile->IsSystemProfile()) {
#if BUILDFLAG(ENABLE_PRINT_PREVIEW)
// The Printing Background Manager holds onto preview dialog WebContents
// whose corresponding print jobs have not yet fully spooled. Make sure
// these get destroyed before tearing down the incognito profile so that
// their RenderFrameHosts can exit in time - see crbug.com/41235373
g_browser_process->background_printing_manager()
- ->DeletePreviewContentsForBrowserContext(&profile_.get());
+ ->DeletePreviewContentsForBrowserContext(weak_profile.get());
#endif
// An incognito profile is no longer needed, this indirectly frees
// its cache and cookies once it gets destroyed at the appropriate time.
- ProfileDestroyer::DestroyOTRProfileWhenAppropriate(&profile_.get());
+ ProfileDestroyer::DestroyOTRProfileWhenAppropriate(weak_profile.get());
}
// If we're exiting, send out the APP_TERMINATING notification to allow other
diff --git chrome/browser/ui/browser_tabstrip.cc chrome/browser/ui/browser_tabstrip.cc
index 0b4f8241e9d4e114d90f3c1747da5cea4ad8c186..e1f9c1ef1e74307cfc4899cccdf27b6de61b09bb 100644
--- chrome/browser/ui/browser_tabstrip.cc
+++ chrome/browser/ui/browser_tabstrip.cc
@@ -35,11 +35,16 @@ content::WebContents* AddAndReturnTabAt(
// Time new tab page creation time. We keep track of the timing data in
// WebContents, but we want to include the time it takes to create the
// WebContents object too.
+ // For CEF use a PageTransition that matches
+ // CefFrameHostImpl::kPageTransitionExplicit.
base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
const GURL resolved_url =
url.is_empty() ? browser->GetBrowserForMigrationOnly()->GetNewTabURL()
: url;
- NavigateParams params(browser, resolved_url, ui::PAGE_TRANSITION_TYPED);
+ NavigateParams params(
+ browser, resolved_url,
+ static_cast<ui::PageTransition>(ui::PAGE_TRANSITION_TYPED |
+ ui::PAGE_TRANSITION_FROM_ADDRESS_BAR));
params.disposition = foreground ? WindowOpenDisposition::NEW_FOREGROUND_TAB
: WindowOpenDisposition::NEW_BACKGROUND_TAB;
params.tabstrip_index = idx;
@@ -98,6 +103,19 @@ content::WebContents* AddWebContents(
// Can't create a new contents for the current tab - invalid case.
DCHECK(disposition != WindowOpenDisposition::CURRENT_TAB);
+#if BUILDFLAG(ENABLE_CEF)
+ if (browser && new_contents) {
+ if (auto* cef_delegate =
+ browser->GetBrowserForMigrationOnly()->cef_delegate()) {
+ new_contents =
+ cef_delegate->AddWebContents(std::move(new_contents));
+ if (!new_contents) {
+ return nullptr;
+ }
+ }
+ }
+#endif
+
NavigateParams params(browser, std::move(new_contents));
params.source_contents = source_contents;
params.url = target_url;
@@ -121,8 +139,6 @@ void CloseWebContents(Browser* browser,
bool add_to_history) {
int index = browser->tab_strip_model()->GetIndexOfWebContents(contents);
if (index == TabStripModel::kNoTab) {
- DUMP_WILL_BE_NOTREACHED()
- << "CloseWebContents called for tab not in our strip";
return;
}
diff --git chrome/browser/ui/browser_window/internal/browser_window_features.cc chrome/browser/ui/browser_window/internal/browser_window_features.cc
index 8efb317f70aded0e916ba991e9958238307d5f7f..b855aebe41e2a4d2e6a91c95455a80129ded33eb 100644
--- chrome/browser/ui/browser_window/internal/browser_window_features.cc
+++ chrome/browser/ui/browser_window/internal/browser_window_features.cc
@@ -237,6 +237,15 @@
BrowserWindowFeatures::BrowserWindowFeatures() = default;
BrowserWindowFeatures::~BrowserWindowFeatures() = default;
+// static
+bool BrowserWindowFeatures::IsNormalBrowser(const Browser* browser) {
+ // CEF normal browsers have TYPE_POPUP.
+ if (browser->is_type_popup() && browser->cef_delegate()) {
+ return true;
+ }
+ return browser->is_type_normal();
+}
+
void BrowserWindowFeatures::Init(BrowserWindowInterface* browser) {
// This is used only for the controllers which will be created on demand
// later.
@@ -636,6 +645,9 @@ void BrowserWindowFeatures::InitPostWindowConstruction(Browser* browser) {
// Foundational state used throughout this function. Computed/assigned early
// so the alphabetical sections below can rely on them.
Profile* const profile = browser_->GetProfile();
+
+ const bool supports_toolbar = IsNormalBrowser(browser);
+
BrowserView* const browser_view =
BrowserView::GetBrowserViewForBrowser(browser);
WebUIBrowserWindow* const webui_browser_window =
@@ -700,18 +712,6 @@ void BrowserWindowFeatures::InitPostWindowConstruction(Browser* browser) {
std::make_unique<ContentsBorderController>(browser_view);
}
- if (browser_view) {
- if (browser_->GetType() == BrowserWindowInterface::Type::TYPE_NORMAL ||
- browser_->GetType() == BrowserWindowInterface::Type::TYPE_POPUP ||
- browser_view->GetIsWebAppType()) {
- data_protection_ui_controller_ =
- GetUserDataFactory()
- .CreateInstance<
- enterprise_data_protection::DataProtectionUIController>(
- *browser_view->browser(), browser_view);
- }
- }
-
#if BUILDFLAG(ENABLE_EXTENSIONS) && (BUILDFLAG(IS_WIN) || BUILDFLAG(IS_MAC))
if (browser_view) {
if (base::FeatureList::IsEnabled(
@@ -849,7 +849,7 @@ void BrowserWindowFeatures::InitPostWindowConstruction(Browser* browser) {
browser, browser->GetTabStripModel(), browser->GetSessionID(),
browser->GetType());
- if (browser->is_type_normal() || browser->is_type_app()) {
+ if (supports_toolbar || browser->is_type_app()) {
toast_service_ = std::make_unique<ToastService>(browser);
}
@@ -887,7 +887,7 @@ void BrowserWindowFeatures::InitPostWindowConstruction(Browser* browser) {
// omnibox and a tab strip). By default most new features should be
// instantiated in this block (please keep this list ordered without taking
// into consideration buildflags, repeating buildflags is ok):
- if (browser->is_type_normal()) {
+ if (supports_toolbar) {
if (browser_view) {
if (base::FeatureList::IsEnabled(features::kGlicActorUi)) {
std::vector<std::pair<views::WebView*, ActorOverlayWebView*>>
@@ -1041,6 +1041,38 @@ void BrowserWindowFeatures::InitPostBrowserViewConstruction(
browser_view);
}
+void BrowserWindowFeatures::InitPostTabModelConstruction(
+ BrowserWindowInterface* interface) {
+ auto* browser_view = BrowserView::GetBrowserViewForBrowser(interface);
+ CHECK(browser_view);
+
+ auto* browser = browser_view->browser();
+ const bool supports_toolbar = IsNormalBrowser(browser);
+
+ if (supports_toolbar) {
+ if (!data_protection_ui_controller_) {
+ data_protection_ui_controller_ =
+ GetUserDataFactory()
+ .CreateInstance<
+ enterprise_data_protection::DataProtectionUIController>(
+ *browser, browser_view);
+ }
+ }
+}
+
+void BrowserWindowFeatures::OnWebContentsCreated(
+ BrowserWindowInterface* interface,
+ content::WebContents* target_contents) {
+#if BUILDFLAG(ENABLE_CEF)
+ auto* browser_view = BrowserView::GetBrowserViewForBrowser(interface);
+ CHECK(browser_view);
+
+ if (auto cef_delegate = browser_view->browser()->cef_delegate()) {
+ cef_delegate->OnWebContentsCreated(target_contents);
+ }
+#endif
+}
+
void BrowserWindowFeatures::TearDownPreBrowserWindowDestruction() {
// Tear down in reverse order of construction: embedder first, then
// InitPostWindowConstruction, then Init. Within each section, members are
diff --git chrome/browser/ui/browser_window/public/browser_window_features.h chrome/browser/ui/browser_window/public/browser_window_features.h
index 97e293aa77130a343cfdf46ad567a1a3da54718e..d2845af6e8f7fc249b6769cebfdfb6fdf36bfaf0 100644
--- chrome/browser/ui/browser_window/public/browser_window_features.h
+++ chrome/browser/ui/browser_window/public/browser_window_features.h
@@ -137,6 +137,9 @@ class CookieControlsController;
} // namespace content_settings
+namespace content {
+class WebContents;
+}
namespace contextual_tasks {
class ContextualTasksBrowserController;
} // namespace contextual_tasks
@@ -262,6 +265,8 @@ class BrowserWindowFeatures {
BrowserWindowFeatures();
~BrowserWindowFeatures();
+ static bool IsNormalBrowser(const Browser* browser);
+
BrowserWindowFeatures(const BrowserWindowFeatures&) = delete;
BrowserWindowFeatures& operator=(const BrowserWindowFeatures&) = delete;
@@ -278,6 +283,16 @@ class BrowserWindowFeatures {
// hierarchy in BrowserView.
void InitPostBrowserViewConstruction(BrowserView* browser_view);
+ // Initialize features that depend on the tab model object being created. May
+ // be called multiple times (on TabModel ceation via Navigate). With CEF this
+ // will be called after BrowserView construction.
+ void InitPostTabModelConstruction(BrowserWindowInterface* browser);
+
+ // Called when a WebContents is created as part of TabModel ceation via
+ // Navigate.
+ void OnWebContentsCreated(BrowserWindowInterface* browser,
+ content::WebContents* target_contents);
+
// Called exactly once to tear down state that depends on the window object.
void TearDownPreBrowserWindowDestruction();
diff --git chrome/browser/ui/browser_window/public/browser_window_interface.h chrome/browser/ui/browser_window/public/browser_window_interface.h
index 5374510d7c3f360748ec598f676ded178981dba4..bf8c6ec25aa48bde0032d6b2aa5695d650a6f7ae 100644
--- chrome/browser/ui/browser_window/public/browser_window_interface.h
+++ chrome/browser/ui/browser_window/public/browser_window_interface.h
@@ -324,6 +324,10 @@ class BrowserWindowInterface : public content::PageNavigator {
// browser window (e.g. most of the 3-dot menu actions).
virtual BrowserActions* GetActions() = 0;
+ // Returns true if this is a normal browser as determined by
+ // BrowserWindowFeatures::IsNormalBrowser.
+ virtual bool IsNormalBrowser() const = 0;
+
// This is used by features that need to operate on most or all tabs in the
// browser window. Do not use this method to find a specific tab.
virtual std::vector<tabs::TabInterface*> GetAllTabInterfaces() = 0;
diff --git chrome/browser/ui/navigator/browser_navigator.cc chrome/browser/ui/navigator/browser_navigator.cc
index a3a2000fe57f7095a85dbbcbbff473d41fdb83b5..f8f4400defe93ddbbb17d05fcb3c11bda755e111 100644
--- chrome/browser/ui/navigator/browser_navigator.cc
+++ chrome/browser/ui/navigator/browser_navigator.cc
@@ -31,6 +31,7 @@
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_init_state.h"
#include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/browser_window/public/browser_window_features.h"
#include "chrome/browser/ui/browser_window/public/browser_window_interface.h"
#include "chrome/browser/ui/browser_window/public/profile_browser_collection.h"
#include "chrome/browser/ui/incognito_allowed_url.h"
@@ -312,6 +313,12 @@ std::tuple<BrowserWindowInterface*, int> GetBrowserAndTabForDisposition(
browser_params.pip_options = pip_options;
+ browser_params.can_resize = pip_options->resizable;
+
+#if BUILDFLAG(ENABLE_CEF)
+ browser_params.opener = params.browser;
+#endif
+
const ui::BaseWindow* const browser_window = params.browser->GetWindow();
const gfx::NativeWindow native_window =
browser_window ? browser_window->GetNativeWindow()
@@ -501,7 +508,13 @@ std::unique_ptr<content::WebContents> CreateTargetContents(
}
#endif
- return WebContents::Create(create_params);
+ std::unique_ptr<WebContents> target_contents =
+ WebContents::Create(create_params);
+
+ params.browser->GetFeatures().OnWebContentsCreated(params.browser,
+ target_contents.get());
+
+ return target_contents;
}
} // namespace
@@ -921,6 +934,11 @@ base::WeakPtr<content::NavigationHandle> NavigateImpl(
// navigation happens in a different tab to the link click.
apps::SetLinkCapturingSourceDisposition(tab_to_insert->GetContents(),
params->disposition);
+
+ // With CEF the BrowserView is created before the TabModel, so we need a
+ // separate initialization of objects that depend on TabModel.
+ params->browser->GetFeatures().InitPostTabModelConstruction(
+ params->browser);
}
if (params->source_contents == contents_to_navigate_or_insert) {
diff --git chrome/browser/ui/views/frame/horizontal_tab_strip_region_view.cc chrome/browser/ui/views/frame/horizontal_tab_strip_region_view.cc
index f994a992e8eaa8124d8633239ec3f13cd43c4b62..988b5b9b15781a42ac0c4c9e335a96dc8613eeb6 100644
--- chrome/browser/ui/views/frame/horizontal_tab_strip_region_view.cc
+++ chrome/browser/ui/views/frame/horizontal_tab_strip_region_view.cc
@@ -205,8 +205,7 @@ HorizontalTabStripRegionViewOld::HorizontalTabStripRegionViewOld(
// Add and configure the TabStripComboButton.
std::unique_ptr<TabStripActionContainer> tab_strip_action_container;
- if (browser &&
- (browser->GetType() == BrowserWindowInterface::Type::TYPE_NORMAL)) {
+ if (browser && browser->IsNormalBrowser()) {
// The Glic button visibility is dynamic and depends on profile state
// (e.g., sign-in status, enterprise policies, recoverable errors).
// We instantiate the action container if the profile is eligible (even if
diff --git chrome/browser/ui/window_metadata/window_metadata_controller.cc chrome/browser/ui/window_metadata/window_metadata_controller.cc
index efdeb4080a66c06cb020529f63d246732f51249b..4ffaab731491243a6cc9d93bc2a4e95ff9f3b9a8 100644
--- chrome/browser/ui/window_metadata/window_metadata_controller.cc
+++ chrome/browser/ui/window_metadata/window_metadata_controller.cc
@@ -63,8 +63,12 @@ WindowMetadataController::WindowMetadataController(
WindowMetadataController::~WindowMetadataController() = default;
gfx::Image WindowMetadataController::GetCurrentPageIcon() const {
+ // For document picture-in-picture windows, we use the favicon from the opener
+ // WebContents instead of the picture-in-picture WebContents itself.
content::WebContents* web_contents =
- browser_->tab_strip_model()->GetActiveWebContents();
+ browser_->is_type_picture_in_picture()
+ ? PictureInPictureWindowManager::GetInstance()->GetWebContents()
+ : browser_->tab_strip_model()->GetActiveWebContents();
// |web_contents| can be NULL since GetCurrentPageIcon() is called by the
// window during the window's creation (before tabs have been added).
favicon::FaviconDriver* favicon_driver =
Reference in new issue View Git Blame Copy Permalink