diff --git chrome/browser/browser_about_handler.cc chrome/browser/browser_about_handler.cc
index 7603c2662b8dc..9a38d816bdc40 100644
--- chrome/browser/browser_about_handler.cc
+++ chrome/browser/browser_about_handler.cc
@@ -69,6 +69,9 @@ bool HandleNonNavigationAboutURL(const GURL& url) {
         FROM_HERE, base::BindOnce(&chrome::AttemptExit));
     return true;
   }
+  if (base::EqualsCaseInsensitiveASCII(spec, "chrome://ignore/")) {
+    return true;
+  }
 
   return false;
 }
diff --git chrome/browser/devtools/devtools_window.cc chrome/browser/devtools/devtools_window.cc
index 8e0717f34f37f..df852d4b2e69f 100644
--- chrome/browser/devtools/devtools_window.cc
+++ chrome/browser/devtools/devtools_window.cc
@@ -38,6 +38,7 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/task_manager/web_contents_tags.h"
+#include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/prefs/prefs_tab_helper.h"
 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
 #include "chrome/browser/ui/tabs/tab_strip_user_gesture_details.h"
@@ -1205,6 +1206,13 @@ DevToolsWindow* DevToolsWindow::Create(
     if (!browser || !browser->is_type_normal()) {
       can_dock = false;
     }
+
+#if BUILDFLAG(ENABLE_CEF)
+    if (can_dock && browser && browser->cef_delegate()) {
+      // Don't dock DevTools for CEF-managed browsers.
+      can_dock = false;
+    }
+#endif
   }
 #endif
 
@@ -1646,7 +1654,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(), fixed_url,
                                   ui::PAGE_TRANSITION_LINK);
@@ -1827,12 +1837,26 @@ void DevToolsWindow::CreateDevToolsBrowser() {
       Browser::CreationStatus::kOk) {
     return;
   }
-  browser_ =
-      Browser::Create(Browser::CreateParams::CreateForDevTools(profile_));
-  browser_->tab_strip_model()->AddWebContents(
-      OwnedMainWebContents::TakeWebContents(
-          std::move(owned_main_web_contents_)),
-      -1, ui::PAGE_TRANSITION_AUTO_TOPLEVEL, AddTabTypes::ADD_ACTIVE);
+  auto* inspected_web_contents = GetInspectedWebContents();
+  auto* opener = chrome::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, 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_->tab_strip_model()->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 51c55cb054ae7..df9aa9bc45a67 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("//chromeos/ash/components/assistant/assistant.gni")
@@ -302,6 +303,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
@@ -329,6 +334,7 @@ static_library("ui") {
     "//build/config/chromebox_for_meetings:buildflags",
     "//build/config/linux/dbus:buildflags",
     "//cc/paint",
+    "//cef/libcef/features:buildflags",
     "//chrome:resources",
     "//chrome:strings",
     "//chrome/app:chrome_dll_resources",
@@ -701,6 +707,13 @@ static_library("ui") {
     deps += [ "//components/plus_addresses/resources:vector_icons" ]
   }
 
+  if (enable_cef) {
+    deps += [
+      "//cef:cef_resources",
+      "//cef/libcef/features:deps",
+    ]
+  }
+
   # TODO(crbug.com/41437292): Remove this circular dependency.
   # Any circular includes must depend on the target "//chrome/browser:browser_public_dependencies".
   # These are all-platform circular includes.
@@ -5501,6 +5514,7 @@ static_library("ui") {
   if (enable_printing) {
     deps += [
       "//components/printing/browser",
+      "//components/printing/common:mojo_interfaces",
       "//printing",
     ]
   }
diff --git chrome/browser/ui/browser.cc chrome/browser/ui/browser.cc
index d45f8f1713c87..de476f1ed4081 100644
--- chrome/browser/ui/browser.cc
+++ chrome/browser/ui/browser.cc
@@ -272,6 +272,25 @@
 #include "components/captive_portal/content/captive_portal_tab_helper.h"
 #endif
 
+#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
+
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/extension_browser_window_helper.h"
 #endif
@@ -571,6 +590,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>(
@@ -818,6 +841,12 @@ Browser::~Browser() {
   if (select_file_dialog_.get()) {
     select_file_dialog_->ListenerDestroyed();
   }
+
+  // Clean up any objects attached via UserData before implicit destruction
+  // of CreateParams. Destruction of those objects may call into something
+  // (ProfileImpl, PrefService, etc) that will be destroyed when the last
+  // CefRequestContextImpl reference (held by CreateParams) is released.
+  ClearAllUserData();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1275,6 +1304,10 @@ BrowserWindowInterface::Type Browser::GetType() const {
   return type_;
 }
 
+bool Browser::IsNormalBrowser() const {
+  return BrowserWindowFeatures::IsNormalBrowser(this);
+}
+
 BrowserUserEducationInterface* Browser::GetUserEducationInterface() {
   return window();
 }
@@ -1436,6 +1469,8 @@ void Browser::WindowFullscreenStateChanged() {
       ->WindowFullscreenStateChanged();
   command_controller_->FullscreenStateChanged();
   UpdateBookmarkBarState(BOOKMARK_BAR_STATE_CHANGE_TOGGLE_FULLSCREEN);
+
+  CALL_CEF_DELEGATE(WindowFullscreenStateChanged);
 }
 
 void Browser::FullscreenTopUIStateChanged() {
@@ -1807,6 +1842,15 @@ content::KeyboardEventProcessingResult Browser::PreHandleKeyboardEvent(
     return content::KeyboardEventProcessingResult::HANDLED;
   }
 
+#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 window()->PreHandleKeyboardEvent(event);
 }
 
@@ -1814,8 +1858,18 @@ bool Browser::HandleKeyboardEvent(content::WebContents* source,
                                   const NativeWebKeyboardEvent& event) {
   DevToolsWindow* devtools_window =
       DevToolsWindow::GetInstanceForInspectedWebContents(source);
-  return (devtools_window && devtools_window->ForwardKeyboardEvent(event)) ||
-         window()->HandleKeyboardEvent(event);
+  if (devtools_window && devtools_window->ForwardKeyboardEvent(event)) {
+    return true;
+  }
+
+#if BUILDFLAG(ENABLE_CEF)
+  if (cef_browser_delegate_ &&
+      cef_browser_delegate_->HandleKeyboardEvent(source, event)) {
+    return true;
+  }
+#endif
+
+  return window()->HandleKeyboardEvent(event);
 }
 
 bool Browser::TabsNeedBeforeUnloadFired() const {
@@ -1910,9 +1964,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) {
@@ -1975,6 +2034,14 @@ WebContents* Browser::OpenURLFromTab(
                                   std::move(navigation_handle_callback));
   }
 
+#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;
@@ -2148,6 +2215,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) {
@@ -2157,6 +2226,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;
   }
@@ -2177,6 +2253,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 =
@@ -2190,6 +2268,17 @@ void Browser::UpdateTargetURL(WebContents* source, const GURL& url) {
   }
 }
 
+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);
+  return false;
+}
+
 void Browser::ContentsMouseEvent(WebContents* source, const ui::Event& event) {
   const ui::EventType type = event.type();
   const bool exited = type == ui::EventType::kMouseExited;
@@ -2223,9 +2312,23 @@ 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);
+}
+
 void Browser::BeforeUnloadFired(WebContents* web_contents,
                                 bool proceed,
                                 bool* proceed_to_fire_unload) {
@@ -2338,12 +2441,24 @@ 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_render_process_id, opener_render_frame_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();
@@ -2356,6 +2471,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(
@@ -2365,6 +2487,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);
 }
 
@@ -2400,6 +2531,11 @@ void Browser::DraggableRegionsChanged(
   if (app_controller_) {
     app_controller_->DraggableRegionsChanged(regions, contents);
   }
+#if BUILDFLAG(ENABLE_CEF)
+  else if (cef_delegate()) {
+    cef_delegate()->DraggableRegionsChanged(regions, contents);
+  }
+#endif
 }
 
 std::vector<blink::mojom::RelatedApplicationPtr>
@@ -2514,11 +2650,15 @@ void Browser::EnterFullscreenModeForTab(
     const blink::mojom::FullscreenOptions& options) {
   exclusive_access_manager_->fullscreen_controller()->EnterFullscreenModeForTab(
       requesting_frame, options.display_id);
+
+  CALL_CEF_DELEGATE(EnterFullscreenModeForTab, requesting_frame, options);
 }
 
 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) {
@@ -2728,6 +2868,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(
@@ -3313,9 +3463,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
@@ -3323,6 +3475,12 @@ std::vector<StatusBubble*> Browser::GetStatusBubbles() {
   // mode, as the minimal browser UI includes the status bar.
   if (web_app::AppBrowserController::IsWebApp(this) &&
       !app_controller()->HasMinimalUiButtons()) {
+    show_by_default = false;
+  }
+
+  bool show = show_by_default;
+  CALL_CEF_DELEGATE_RESULT(ShowStatusBubble, show, show_by_default);
+  if (!show) {
     return {};
   }
 
@@ -3476,6 +3634,8 @@ void Browser::SetAsDelegate(WebContents* web_contents, bool set_delegate) {
     BookmarkTabHelper::FromWebContents(web_contents)->RemoveObserver(this);
     web_contents_collection_.StopObserving(web_contents);
   }
+
+  CALL_CEF_DELEGATE(SetAsDelegate, web_contents, set_delegate);
 }
 
 void Browser::TabDetachedAtImpl(content::WebContents* contents,
@@ -3637,6 +3797,14 @@ bool Browser::PictureInPictureBrowserSupportsWindowFeature(
 
 bool Browser::SupportsWindowFeatureImpl(WindowFeature feature,
                                         bool check_can_support) const {
+#if BUILDFLAG(ENABLE_CEF)
+  if (cef_delegate()) {
+    if (auto value = cef_delegate()->SupportsWindowFeature(feature)) {
+      return *value;
+    }
+  }
+#endif
+
   switch (type_) {
     case TYPE_NORMAL:
       return NormalBrowserSupportsWindowFeature(feature, check_can_support);
diff --git chrome/browser/ui/browser.h chrome/browser/ui/browser.h
index ce1e404e45a60..7193496de6b31 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/themes/theme_service_observer.h"
 #include "chrome/browser/ui/bookmarks/bookmark_bar.h"
@@ -54,6 +55,10 @@
 #include "ui/gfx/geometry/rect.h"
 #include "ui/shell_dialogs/select_file_dialog.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
@@ -351,6 +356,15 @@ class Browser : public TabStripModelObserver,
     // Document Picture in Picture options, specific to TYPE_PICTURE_IN_PICTURE.
     std::optional<blink::mojom::PictureInPictureWindowOptions> pip_options;
 
+#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<Browser, DanglingUntriaged> opener = nullptr;
+#endif
+
    private:
     friend class Browser;
     friend class WindowSizerChromeOSTest;
@@ -434,6 +448,13 @@ 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_; }
+
   // Accessors ////////////////////////////////////////////////////////////////
 
   const CreateParams& create_params() const { return create_params_; }
@@ -535,6 +556,12 @@ class Browser : public TabStripModelObserver,
   base::WeakPtr<Browser> AsWeakPtr();
   base::WeakPtr<const Browser> AsWeakPtr() const;
 
+#if BUILDFLAG(ENABLE_CEF)
+  cef::BrowserDelegate* cef_delegate() const {
+    return cef_browser_delegate_.get();
+  }
+#endif
+
   // Get the FindBarController for this browser, creating it if it does not
   // yet exist.
   FindBarController* GetFindBarController();
@@ -889,6 +916,7 @@ class Browser : public TabStripModelObserver,
   ImmersiveModeController* GetImmersiveModeController() override;
   BrowserActions* GetActions() override;
   Type GetType() const override;
+  bool IsNormalBrowser() const override;
   BrowserUserEducationInterface* GetUserEducationInterface() override;
   web_app::AppBrowserController* GetAppBrowserController() override;
   std::vector<tabs::TabInterface*> GetAllTabInterfaces() override;
@@ -991,10 +1019,18 @@ class Browser : public TabStripModelObserver,
   void SetContentsBounds(content::WebContents* source,
                          const gfx::Rect& bounds) override;
   void UpdateTargetURL(content::WebContents* source, const GURL& url) override;
+  bool DidAddMessageToConsole(content::WebContents* source,
+                              blink::mojom::ConsoleMessageLevel log_level,
+                              const std::u16string& message,
+                              int32_t line_no,
+                              const std::u16string& source_id) override;
   void ContentsMouseEvent(content::WebContents* source,
                           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;
   void BeforeUnloadFired(content::WebContents* source,
                          bool proceed,
                          bool* proceed_to_fire_unload) override;
@@ -1341,6 +1377,10 @@ 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
+
   std::unique_ptr<TabStripModelDelegate> const tab_strip_model_delegate_;
   std::unique_ptr<TabStripModel> const tab_strip_model_;
 
@@ -1407,6 +1447,8 @@ class Browser : public TabStripModelObserver,
   const std::string initial_workspace_;
   bool initial_visible_on_all_workspaces_state_;
 
+  bool toolbar_overridden_ = false;
+
   CreationSource creation_source_ = CreationSource::kUnknown;
 
   UnloadController unload_controller_;
diff --git chrome/browser/ui/browser_navigator.cc chrome/browser/ui/browser_navigator.cc
index cefd4bc59943a..69425ab604ddb 100644
--- chrome/browser/ui/browser_navigator.cc
+++ chrome/browser/ui/browser_navigator.cc
@@ -260,6 +260,10 @@ std::tuple<Browser*, int> GetBrowserAndTabForDisposition(
 
       browser_params.pip_options = pip_options;
 
+#if BUILDFLAG(ENABLE_CEF)
+      browser_params.opener = params.browser;
+#endif
+
       const BrowserWindow* const browser_window = params.browser->window();
       const gfx::NativeWindow native_window =
           browser_window ? browser_window->GetNativeWindow()
@@ -547,7 +551,17 @@ std::unique_ptr<content::WebContents> CreateTargetContents(
   }
 #endif
 
-  return WebContents::Create(create_params);
+  std::unique_ptr<WebContents> target_contents =
+      WebContents::Create(create_params);
+
+#if BUILDFLAG(ENABLE_CEF)
+  auto cef_delegate = params.browser->cef_delegate();
+  if (cef_delegate) {
+    cef_delegate->OnWebContentsCreated(target_contents.get());
+  }
+#endif
+
+  return target_contents;
 }
 
 bool IsHostAllowedInIncognito(const GURL& url) {
diff --git chrome/browser/ui/browser_tabstrip.cc chrome/browser/ui/browser_tabstrip.cc
index 83a510defbda5..f4305701c5f5a 100644
--- chrome/browser/ui/browser_tabstrip.cc
+++ chrome/browser/ui/browser_tabstrip.cc
@@ -33,9 +33,13 @@ 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();
   NavigateParams params(browser, url.is_empty() ? browser->GetNewTabURL() : url,
-                        ui::PAGE_TRANSITION_TYPED);
+                        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;
@@ -86,6 +90,16 @@ 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 && browser->cef_delegate() && new_contents) {
+    new_contents = browser->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;
diff --git chrome/browser/ui/browser_window/browser_window_features.cc chrome/browser/ui/browser_window/browser_window_features.cc
index 274b403d01d91..4dd3239bf5f48 100644
--- chrome/browser/ui/browser_window/browser_window_features.cc
+++ chrome/browser/ui/browser_window/browser_window_features.cc
@@ -92,6 +92,15 @@ BrowserWindowFeatures::CreateBrowserWindowFeatures() {
 
 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();
+}
+
 // static
 void BrowserWindowFeatures::ReplaceBrowserWindowFeaturesForTesting(
     BrowserWindowFeaturesFactory factory) {
@@ -168,10 +177,12 @@ void BrowserWindowFeatures::Init(BrowserWindowInterface* browser) {
 }
 
 void BrowserWindowFeatures::InitPostWindowConstruction(Browser* browser) {
+  const bool supports_toolbar = IsNormalBrowser(browser);
+
   // Features that are only enabled for normal browser windows (e.g. a window
   // with an omnibox and a tab strip). By default most features should be
   // instantiated in this block.
-  if (browser->is_type_normal()) {
+  if (supports_toolbar) {
     if (IsChromeLabsEnabled()) {
       chrome_labs_coordinator_ =
           std::make_unique<ChromeLabsCoordinator>(browser);
@@ -213,7 +224,7 @@ void BrowserWindowFeatures::InitPostWindowConstruction(Browser* browser) {
     }
   }
 
-  if ((browser->is_type_normal() || browser->is_type_app()) &&
+  if ((supports_toolbar || browser->is_type_app()) &&
       base::FeatureList::IsEnabled(toast_features::kToastFramework)) {
     toast_service_ = std::make_unique<ToastService>(browser);
   }
@@ -251,10 +262,12 @@ void BrowserWindowFeatures::InitPostBrowserViewConstruction(
           browser_view->browser(),
           side_panel_coordinator_->GetWindowRegistry());
 
+  const bool supports_toolbar = IsNormalBrowser(browser_view->browser());
+
   // Memory Saver mode is default off but is available to turn on.
   // The controller relies on performance manager which isn't initialized in
   // some unit tests without browser view.
-  if (browser_view->GetIsNormalType()) {
+  if (supports_toolbar) {
 #if BUILDFLAG(ENABLE_GLIC)
     if (glic::GlicEnabling::IsProfileEligible(
             browser_view->browser()->profile())) {
diff --git chrome/browser/ui/browser_window/public/browser_window_features.h chrome/browser/ui/browser_window/public/browser_window_features.h
index a318b2507f3ca..04bed96bbe382 100644
--- chrome/browser/ui/browser_window/public/browser_window_features.h
+++ chrome/browser/ui/browser_window/public/browser_window_features.h
@@ -81,6 +81,8 @@ class BrowserWindowFeatures {
   static std::unique_ptr<BrowserWindowFeatures> CreateBrowserWindowFeatures();
   virtual ~BrowserWindowFeatures();
 
+  static bool IsNormalBrowser(const Browser* browser);
+
   BrowserWindowFeatures(const BrowserWindowFeatures&) = delete;
   BrowserWindowFeatures& operator=(const BrowserWindowFeatures&) = delete;
 
diff --git chrome/browser/ui/browser_window/public/browser_window_interface.h chrome/browser/ui/browser_window/public/browser_window_interface.h
index f2b51e7923e96..644d0655ea6c9 100644
--- chrome/browser/ui/browser_window/public/browser_window_interface.h
+++ chrome/browser/ui/browser_window/public/browser_window_interface.h
@@ -196,6 +196,10 @@ class BrowserWindowInterface : public content::PageNavigator {
   };
   virtual Type GetType() const = 0;
 
+  // Returns true if this is a normal browser as determined by
+  // BrowserWindowFeatures::IsNormalBrowser.
+  virtual bool IsNormalBrowser() const = 0;
+
   // Gets an object that provides common per-browser-window functionality for
   // user education. The remainder of functionality is provided directly by the
   // UserEducationService, which can be retrieved directly from the profile.
diff --git chrome/browser/ui/views/frame/tab_strip_region_view.cc chrome/browser/ui/views/frame/tab_strip_region_view.cc
index b0a946ad9168f..0f7daf3eb0255 100644
--- chrome/browser/ui/views/frame/tab_strip_region_view.cc
+++ chrome/browser/ui/views/frame/tab_strip_region_view.cc
@@ -118,8 +118,7 @@ TabStripRegionView::TabStripRegionView(std::unique_ptr<TabStrip> tab_strip)
   std::unique_ptr<TabStripActionContainer> tab_strip_action_container;
   std::unique_ptr<TabStripComboButton> tab_strip_combo_button;
   std::unique_ptr<ProductSpecificationsButton> product_specifications_button;
-  if (browser &&
-      (browser->GetType() == BrowserWindowInterface::Type::TYPE_NORMAL)) {
+  if (browser && browser->IsNormalBrowser()) {
     if (features::IsTabSearchMoving() &&
         !features::HasTabSearchToolbarButton() &&
         ShouldShowNewTabButton(browser)) {