One important technical aspect of this change is the usage of BUILDFLAG(ENABLE_CEF) when patching Chromium code. We will need to introduce a runtime check for choosing between CEF and Chrome behaviors in these patches, instead of just compiling in the CEF-specific behaviors when building CEF.

‌

GTK is required for the Chrome runtime on Linux (see here), so use_gtk=true must be specified via GN_DEFINES on that platform.

Refactor process execution logic (see issue #2969)

CefContext implements the public CEF API functions and delegates
the stages of content & service_manager process execution to
CefMainRunner. CEF-specific runtime logic (which may be replaced
with chrome-specific runtime logic) is then delegated to
CefMainDelegate which implements content::ContentMainDelegate.

→ <<cset 049caf913106 (bb)>>

Add initial chrome runtime support (see issue #2969)

Running cefsimple --enable-chrome-runtime will create and run a
Chrome browser window using the CEF app methods, and call
CefApp::OnContextInitialized as expected. CEF task methods also
work as expected in the main process. No browser-related methods or
callbacks are currently supported for the Chrome window, and the
application will exit when the last Chrome window closes.

The Chrome runtime requires resources.pak, chrome_100_percent.pak
and chrome_200_percent.pak files which were not previously built
with CEF. It shares the existing locales pak files which have been
updated to include additional Chrome-specific strings.

On Linux, the Chrome runtime requires GTK so use_gtk=true must be
specified via GN_DEFINES when building.

This change also refactors the CEF runtime, which can be tested in
the various supported modes by running:
$ cefclient
$ cefclient --multi-threaded-message-loop
$ cefclient --external-message-pump

→ <<cset 117499421184 (bb)>>

Set enable_background_mode=false by default (see issue #2969)

This mode doesn"t make sense with CEF, and it was causing strange
shutdown crashes when running with Chrome mode enabled.

→ <<cset f5587b74f0aa (bb)>>

Rename the current CEF runtime to Alloy (see issue #2969)

As part of introducing the Chrome runtime we now need to distinguish
between the classes that implement the current CEF runtime and the
classes the implement the shared CEF library/runtime structure and
public API. We choose the name Alloy for the current CEF runtime
because it describes a combination of Chrome and other elements.

Shared CEF library/runtime classes will continue to use the Cef
prefix. Classes that implement the Alloy or Chrome runtime will use
the Alloy or Chrome prefixes respectively. Classes that extend an
existing Chrome-prefixed class will add the Cef or Alloy suffix,
thereby following the existing naming pattern of Chrome-derived
classes.

This change applies the new naming pattern to an initial set of
runtime-related classes. Additional classes/files will be renamed
and moved as the Chrome runtime implementation progresses.

→ <<cset 84f3ff2afda7 (bb)>>

Add CefAppManager and remove global ContentClient accessors (see issue #2969)

This is the first pass in removing direct dependencies on the Alloy
runtime from code that can potentially be shared between runtimes.

CefBrowserHost and CefRequestContext APIs (including CefCookieManager,
CefURLRequest, etc.) are not yet implemented for the Chrome runtime.
Assert early if these API methods are called while the Chrome runtime
is enabled.

→ <<cset b3a8da9b25dc (bb)>>

Make CefBrowserContext an abstract base class (see issue #2969)

Existing CefBrowserContext functionality is now split between
CefBrowserContext and AlloyBrowserContext. Runtime implementations of
CefBrowserContext will provide access to the content::BrowserContext and
Profile types via different inheritance paths. For example, the Alloy
runtime uses ChromeProfileAlloy and the Chrome runtime uses ProfileImpl.

This change also renames CefResourceContext to CefIOThreadState to more
accurately represent its purpose as it no longer needs to extend
content::ResourceContext.

→ <<cset 48fc0bd2206d (bb)>>

Move browser runtime-specific logic to CefBrowserPlatformDelegate (see issue #2969)

This change moves the runtime-specific implementations of CefBrowserHostImpl
methods to CefBrowserPlatformDelegate. Some WebContentsDelegate methods
implemented by CefBrowserHostImpl set state or trigger client callbacks.
Those implementations will likely stay with CefBrowserHostImpl and will
need to be called from the Browser equivalents when using the Chrome runtime.

→ <<cset 6cb9f0c695b9 (bb)>>

Add initial Chrome runtime support for browser APIs (see issue #2969)

This change adds basic Chrome runtime implementations for CefBrowserContext
and CefBrowserPlatformDelegate. A Chrome browser window with default frame
and styling can now be created using CefBrowserHost::CreateBrowser and some
CefClient callbacks will be triggered via the WebContentsObserver
implementation in CefBrowserHostImpl.

Any additional browser windows created via the Chrome UI will be unmanaged
by CEF. The application message loop will block until all browser windows
have been closed by the user.

→ <<cset e9bf3cdb9852 (bb)>>

Move Alloy-specific logic to CefBrowserPlatformDelegateAlloy (see issue #2969)

Also remove OSR-related methods where the attributes can instead be passed
to the OSR platform delegate constructor directly.

→ <<cset 02cdf05848ea (bb)>>

Fix build and initial Chrome runtime issues on macOS (see issue #2969)

This change moves shared resource initialization to a common location and
disables crash reporting initialization in chrome/ code via patch files.

When using the Chrome runtime on macOS the Chrome application window will
display, but web content is currently blank and the application does not
exit cleanly. This will need to be debugged further in the future.

→ <<cset 03c9156c803c (bb)>>

Fix official build errors caused by chrome runtime changes (see issue #2969)

→ <<cset 13e3c8b42a7a (bb)>>

The next step is supporting observers and delegates on the chrome Browser object.

• Identify the best place to intercept all Browser creation for the purposes of attaching CEF objects. [new Browser](https://source.chromium.org/search?q="new Browser(" -test -java&sq=&ss=chromium/chromium/src) usage is common, so registering a static callback for use from the Browser constructor may be best.
• Patch browser.h/browser.cc to intercept WebContentsDelegate callbacks where necessary.
• Move common WebContentsObserver and WebContentsDelegate functionality from CefBrowserHostImpl to a separate shared class.

‌

Update chrome_browser_net_export patch for chrome runtime (see issue #2969)

→ <<cset 7ca9e9c54bc3 (bb)>>

Create a ChromeBrowserHostImpl for every Chrome tab (see issue #2969)

The Browser object represents the top-level Chrome browser window. One or more
tabs (WebContents) are then owned by the Browser object via TabStripModel. A
new Browser object can be created programmatically using "new Browser" or
Browser::Create, or as a result of user action such as dragging a tab out of an
existing window. New or existing tabs can also be added to an already existing
Browser object.

The Browser object acts as the WebContentsDelegate for all attached tabs. CEF
integration requires WebContentsDelegate callbacks and notification of tab
attach/detach. To support this integration we add a cef::BrowserDelegate
(ChromeBrowserDelegate) member that is created in the Browser constructor and
receives delegation for the Browser callbacks. ChromeBrowserDelegate creates a
new ChromeBrowserHostImpl when a tab is added to a Browser for the first time,
and that ChromeBrowserHostImpl continues to exist until the tab"s WebContents
is destroyed. The associated WebContents object does not change, but the
Browser object will change when the tab is dragged between windows.

CEF callback logic is shared between the chrome and alloy runtimes where
possible. This shared logic has been extracted from CefBrowserHostImpl to
create new CefBrowserHostBase and CefBrowserContentsDelegate classes. The
CefBrowserHostImpl class is now only used with the alloy runtime and will be
renamed to AlloyBrowserHostImpl in a future commit.

→ <<cset 38d8acfa186c (bb)>>

Rename CefBrowserHostImpl to AlloyBrowserHostImpl (see issue #2969)

After commit 38d8acfa18 (bb) this object is only used with the alloy runtime.

→ <<cset e94a261bf518 (bb)>>

Add chrome runtime support for more callbacks and ceftests (see issue #2969)

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).
• Support loading of 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.*
DOMTest.*
DisplayTest.*:-DisplayTest.AutoResize
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.*

They can be run with this command-line:

ceftests --enable-chrome-runtime --gtest_filter=CorsTest.*:DisplayTest.*:DOMTest.*:DraggableRegionsTest.*:ImageTest.*:MessageRouterTest.*:NavigationTest.*:ParserTest.*:RequestContextTest.*Global*:RequestTest.*:ResourceManagerTest.*:ResourceRequestHandlerTest.*:ResponseTest.*:SchemeHandlerTest.*:ServerTest.*:StreamResourceHandlerTest.*:StreamTest.*:StringTest.*:TaskTest.*:TestServerTest.*:ThreadTest.*:URLRequestTest.*Global*:V8Test.*:ValuesTest.*:WaitableEventTest.*:XmlReaderTest.*:ZipReaderTest.*:-V8Test.OnUncaughtExceptionDevTools:DisplayTest.AutoResize

→ <<cset 4fbd2472310b (bb)>>

Fix chrome runtime startup assertion and PDF loading (see issue #2969)

→ <<cset 92508bcc871c (bb)>>

chrome: Fix callbacks for different Profile types (see issue #2969)

• Only install network intercepts for Profiles that have an associated
  CefBrowserContext. For incognito windows the CefBrowserContext is
  associated with the OffTheRecordProfileImpl"s original Profile.
• cefsimple: Return the default CefClient instance for browser windows
  created via the Chrome UI, and allow Chrome to show error pages.

→ <<cset ec7067c55ee1 (bb)>>

chrome: Add CEF-specific WebUI handling (see issue #2969)

To avoid conflicting IDs between Alloy (which uses cef.pak) and Chrome (which uses chrome_100_percent.pak) the cef/LICENSE.txt file is now included in both cef/libcef/resources/cef_resources.grd and chrome/app/theme/chrome_unscaled_resources.grd with different ID values.

The cef.pak file currently contains both CEF-specific resources and Chrome resources that are already included in the default .pak files distributed with Chrome. In the future we should remove this duplication and just distribute the same .pak files as Chrome for the majority of resources.

→ <<cset 8f5fdc1f9adb (bb)>>

‌

Chrome + Views is testable on all platforms (Windows, Linux, MacOS) with builds of M90 and newer. It is considered MVP complete (meaning all basic functionality has been implemented/tested) with M101.

• Separate issues have been filed here for remaining Chrome runtime functionality.
• Please create new issues as needed.
• Future updates related to test coverage will be posted here.
• See below for expected/intentional behavioral differences.

To launch a fully-featured Chrome window using cefsimple:

$ cefsimple --enable-chrome-runtime

To launch a minimally-styled Views-hosted window using cefsimple:

$ cefsimple --use-views --enable-chrome-runtime

To launch a fully-styled Views-hosted window using cefclient:

$ cefclient --use-views --enable-chrome-runtime

Use open [name].app --args [arguments] when launching the app on MacOS.

Expected/intentional behaviors that differ from the Alloy runtime:

• Singleton app behavior will be enforced based on the CefSettings.root_cache_path / CefSettings.user_data_path value (details).
• Off-screen rendering and related capabilities are not supported (see issue chrome: Add support for off-screen rendering #3293).
• Embedded non-Views windows are not supported (see issue chrome: Add support for embedded non-Views windows #3294).

The following ceftests are not yet supported with the "--enable-chrome-runtime" command-line flag:

AudioOutputTest.*                   (missing functionality)
DialogTest.*                        (will not be supported at this time)
DisplayTest.AutoResize              (will not be supported at this time)
DownloadTest.*                      (missing functionality)
ExtensionTest.*                     (will not be supported at this time)
JSDialogTest.*                      (will not be supported at this time)
LifeSpanTest.*                      (missing functionality)
OSRTest.*                           (will not be supported at this time)
V8Test.OnUncaughtExceptionDevTools  (missing functionality)

All remaining (supported) tests can be run with this command-line:

ceftests --enable-chrome-runtime --gtest_filter=-AudioOutputTest.*:DialogTest.*:DisplayTest.AutoResize:DownloadTest.*:ExtensionTest.*:JSDialogTest.*:LifeSpanTest.*:OSRTest.*:V8Test.OnUncaughtExceptionDevTools

‌

chrome: Add Views API integration (see issue #2969)

The Chrome browser can now be hosted in a Views-based application on Windows
and Linux.

To launch a fully-featured Chrome window using cefsimple:
$ cefsimple --enable-chrome-runtime

To launch a minimally-styled Views-hosted window using cefsimple:
$ cefsimple --enable-chrome-runtime --use-views

To launch a fully-styled Views-hosted window using cefclient:
$ cefclient --enable-chrome-runtime --use-views

Views unit tests also now pass with the Chrome runtime enabled:
$ ceftests --gtest_filter=Views* --enable-chrome-runtime

Known issues:

• Popup browsers cannot be intercepted and reparented.

→ <<cset 8733cb89c74a (bb)>>

Mac: Add Views API support (see issue #1749)

The Chrome browser can now be hosted in a Views-based application on Mac
(see issue #2969).

To launch a fully-featured Chrome window using cefsimple:
$ open cefsimple.app --args --enable-chrome-runtime

To launch a minimally-styled Views-hosted window using cefsimple:
$ open cefsimple.app --args --use-views [--enable-chrome-runtime]

To launch a fully-styled Views-hosted window using cefclient:
$ open cefclient.app --args --use-views [--enable-chrome-runtime]

Known issues:

• Some Views unit tests are currently failing on Mac.

→ <<cset 1d39ff720e3e (bb)>>

chrome: Fix URL rewrite on new tab navigation (see issue #2969)

This fixes an Unhandled chrome.send("getApps"); error when creating a new tab.

Creating a new tab initially loads chrome://newtab which should then be
rewritten to chrome://new-tab-page for normal profiles in
HandleNewTabURLRewrite. Failure to rewrite the URL results in the loading of
NewTabUI instead of the expected NewTabPageUI. NewTabUI loads different
resources for normal vs incognito/guest profiles (new_tab.js vs
incognito_tab.js), and new_tab.js calls chrome.send("getApps") via
page_list_view.js. This then fails in WebUIImpl::ProcessWebUIMessage because
the message is unhandled.

→ <<cset a6a8c0e845e8 (bb)>>

Use the same pak files for the Alloy and Chrome runtimes (see issue #2969)

Chrome currently uses chrome_100_percent.pak, chrome_200_percent.pak,
resources.pak and locales/.pak files. This change adds CEF
resources to those existing pak files and updates the Alloy runtime to
use them instead of the previous CEF-specific pak files (cef.pak,
cef_100_percent.pak, cef_200_percent.pak, cef_extensions.pak,
devtools_resources.pak) which are no longer generated.

The addition of Chrome resources results in an ~16% (~4.1MB) increase in total
combined pak file size vs. the previous CEF-specific pak files. While a size
increase is not ideal for the Alloy runtime, it seems preferable to the
alternative of distributing separate (and partially duplicated) pak files for
each runtime, which would have added ~9.8MB to the total binary distribution
size.

→ <<cset 8424f166ccef (bb)>>

Linux: cefclient: Port to GTK3 (see issue #2969)

GTK3 is required by the Chrome runtime. The cefclient off-screen rendering
example no longer works with Ubuntu 16.04. With end-of-life in April 2021
we are dropping support for 16.04 in the near future in any case.

→ <<cset 020ac1b50972 (bb)>>

Linux: Enable GTK3 by default (see issue #2969)

GTK3 is required by the Chrome runtime. Client applications using GTK2 will
now require a custom build of CEF with use_gtk=false set via GN_DEFINES.

→ <<cset c4baba880e0b (bb)>>

chrome: Add DevTools protocol support (see issue #2969)

Testable with the following:
$ ceftests --enable-chrome-runtime --gtest_filter=DevToolsMessageTest.*

→ <<cset 505bf24abb6a (bb)>>

chrome: Add support for reparenting of popups with Views (see issue #2969)

→ <<cset 25701cfa6fc2 (bb)>>