Enable support for CEF 6613+ and Chrome Runtime

Add a dummy Browser Client to introduce limitations into the Chrome UI
windows that can be opened in uncontrolled edge cases. Chrome UI windows
are unmanaged by default. By returning something other than null in
GetDefaultClient() we can lock it down in various ways.

OnBeforePopup, OnOpenURLFromTab can probably be removed as they don't
get called. There's no direct way to stop the Chrome UI window from
being opened, so instead close it immediately.

Disable Various Chrome Settings in custom docks & browser sources
via SetPreferences. For more, check `chrome/common/pref_names.h`.

Chrome's default error display is now used by CEF, so on top of the
existing override in browser docks, a similar override has been added
to browser sources which just redirects to about:blank.

Also blocks
 - Chrome Extensions, as they are largely untested and unpredictable
 - MediaRouter, which provides Cast.. functionality
 - CalculateNativeWinOcclusion, which lowers FPS for hidden pages
 - LiveCaption, which provides automatic captions
 - DocumentPictureInPictureAPI, which provides PiP widgets (YouTube)
 - StorageNotificationService, when approaching low cache space

A data migration function is included. It moves some directories into a
new 'Default' profile subdirectory, and performs the necessary renaming
of certain files to ensure the new Profile loads.
Additionally, the cookie directories for each service integration must
be moved into the root config directory, as subdirectories in their
current form (obs_profile_cookies/<cookie_id>) are not supported. This
is intentional, and according to Marshall this was never a supported
setup. cache_path *must* be a direct child of the root_cache_path.
Invalid cache_path_ is silently treated as Incognito Mode and cookies
are not stored.

Author: WizardCM

CMakeLists.txt

@@ -25,6 +25,8 @@ target_sources(
           browser-app.hpp
           browser-client.cpp
           browser-client.hpp
+          browser-dummy-client.cpp
+          browser-dummy-client.hpp
           browser-scheme.cpp
           browser-scheme.hpp
           browser-version.h

browser-app.cpp

@@ -48,11 +48,62 @@ CefRefPtr<CefBrowserProcessHandler> BrowserApp::GetBrowserProcessHandler()
 	return this;
 }
 
+CefRefPtr<CefClient> BrowserApp::GetDefaultClient()
+{
+	return GetDummy();
+}
+
 void BrowserApp::OnRegisterCustomSchemes(CefRawPtr<CefSchemeRegistrar> registrar)
 {
 	registrar->AddCustomScheme("http", CEF_SCHEME_OPTION_STANDARD | CEF_SCHEME_OPTION_CORS_ENABLED);
 }
 
+void BrowserApp::OnContextInitialized()
+{
+	// Without a default client, CefBrowser is unmanaged, allowing full-blown Chromium windows outside of our control
+	// We don't actually want those, so define a dummy client which will automatically close any such windows
+	dummy = new BrowserDummyClient();
+
+	CefRefPtr<CefRequestContext> requestContext = CefRequestContext::GetGlobalContext();
+	CefString errorMessage;
+	CefRefPtr<CefValue> optionValue = CefValue::Create();
+
+	constexpr std::array<std::string_view, 20> kBrowserFeaturesToDisable{
+		"autofill.credit_card_enabled",
+		"autofill.enabled",
+		"autofill.iban_enabled",
+		"autofill.payment_card_benefits",
+		"autofill.payment_cvc_storage",
+		"autofill.profile_enabled",
+		"autologin.enabled",
+		"browser_labs_enabled",
+		"credentials_enable_autosignin",
+		"credentials_enable_service",
+		"payments.can_make_payment_enabled",
+		"printing.enabled",
+		"search.suggest_enabled",
+		"shopping_list_enabled",
+		"side_panel.google_search_side_panel_enabled",
+		"side_search.enabled",
+		"signin.allowed",
+		"signin.allowed_on_next_startup",
+		"translate",
+		"url_keyed_anonymized_data_collection.enabled"};
+
+	constexpr std::array<std::string_view, 2> kBrowserFeaturesToEnable{"extensions.block_external_extensions",
+									   "extensions.disabled"};
+
+	optionValue->SetBool(false);
+	for (std::string_view feature : kBrowserFeaturesToDisable) {
+		requestContext->SetPreference(feature.data(), optionValue.get(), errorMessage);
+	}
+
+	optionValue->SetBool(true);
+	for (std::string_view feature : kBrowserFeaturesToEnable) {
+		requestContext->SetPreference(feature.data(), optionValue.get(), errorMessage);
+	}
+}
+
 void BrowserApp::OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> command_line)
 {
 #ifdef _WIN32
@@ -82,16 +133,35 @@ void BrowserApp::OnBeforeCommandLineProcessing(const CefString &, CefRefPtr<CefC
 		disableFeatures += ",EnableWindowsGamingInputDataFetcher";
 #endif
 		disableFeatures += ",WebBluetooth";
+		disableFeatures += ",MediaRouter";
+		disableFeatures += ",CalculateNativeWinOcclusion";
+		disableFeatures += ",LiveCaption";
+		// https://github.com/chromiumembedded/cef/issues/3966
+		disableFeatures += ".StorageNotificationService";
 		command_line->AppendSwitchWithValue("disable-features", disableFeatures);
 	} else {
 		command_line->AppendSwitchWithValue("disable-features", "WebBluetooth,"
 #ifdef _WIN32
 									"EnableWindowsGamingInputDataFetcher,"
 #endif
+									"MediaRouter,"
+									"CalculateNativeWinOcclusion,"
+									"LiveCaption,"
+									"StorageNotificationService,"
 									"HardwareMediaKeyHandling");
 	}
 
+	if (command_line->HasSwitch("disable-blink-features")) {
+		std::string disableBlinkFeatures = command_line->GetSwitchValue("disable-blink-features");
+		disableBlinkFeatures += ",DocumentPictureInPictureAPI";
+		command_line->AppendSwitchWithValue("disable-blink-features", disableBlinkFeatures);
+	} else {
+		command_line->AppendSwitchWithValue("disable-blink-features", "DocumentPictureInPictureAPI");
+	}
+
 	command_line->AppendSwitchWithValue("autoplay-policy", "no-user-gesture-required");
+	command_line->AppendSwitch("disable-extensions");
+	command_line->AppendSwitch("hide-crash-restore-bubble");
 #ifdef __APPLE__
 	command_line->AppendSwitch("use-mock-keychain");
 #elif !defined(_WIN32)

browser-app.hpp

@@ -22,6 +22,7 @@
 #include <unordered_map>
 #include <functional>
 #include "cef-headers.hpp"
+#include "browser-dummy-client.hpp"
 
 typedef std::function<void(CefRefPtr<CefBrowser>)> BrowserFunc;
 
@@ -85,6 +86,8 @@ class BrowserApp : public CefApp, public CefRenderProcessHandler, public CefBrow
 
 	virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler() override;
 	virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler() override;
+	virtual CefRefPtr<CefClient> GetDefaultClient() override;
+	virtual void OnContextInitialized() override;
 	virtual void OnBeforeChildProcessLaunch(CefRefPtr<CefCommandLine> command_line) override;
 	virtual void OnRegisterCustomSchemes(CefRawPtr<CefSchemeRegistrar> registrar) override;
 	virtual void OnBeforeCommandLineProcessing(const CefString &process_type,
@@ -106,5 +109,9 @@ class BrowserApp : public CefApp, public CefRenderProcessHandler, public CefBrow
 	QTimer frameTimer;
 #endif
 
+	CefRefPtr<BrowserDummyClient> dummy = nullptr;
+
+	BrowserDummyClient *GetDummy() const { return dummy.get(); };
+
 	IMPLEMENT_REFCOUNTING(BrowserApp);
 };

browser-client.cpp

@@ -626,6 +626,17 @@ void BrowserClient::OnLoadEnd(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame> frame,
 	}
 }
 
+void BrowserClient::OnLoadError(CefRefPtr<CefBrowser>, [[maybe_unused]] CefRefPtr<CefFrame> frame,
+				CefLoadHandler::ErrorCode, const CefString &, const CefString &)
+{
+#if CHROME_VERSION_BUILD > 6533
+	// CEF doesn't currently provide a way to properly disable/override the default Chrome error page
+	// https://github.com/obsproject/obs-studio/issues/13499
+	// FIXME: https://github.com/chromiumembedded/cef/issues/3852
+	frame->LoadURL("about:blank");
+#endif
+}
+
 bool BrowserClient::OnConsoleMessage(CefRefPtr<CefBrowser>, cef_log_severity_t level, const CefString &message,
 				     const CefString &source, int line)
 {

browser-client.hpp

@@ -146,5 +146,9 @@ class BrowserClient : public CefClient,
 	/* CefLoadHandler */
 	virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, int httpStatusCode) override;
 
+	virtual void OnLoadError(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
+				 CefLoadHandler::ErrorCode errorCode, const CefString &errorText,
+				 const CefString &failedUrl) override;
+
 	IMPLEMENT_REFCOUNTING(BrowserClient);
 };

browser-dummy-client.cpp

@@ -0,0 +1,71 @@
+
+#include "browser-dummy-client.hpp"
+
+CefRefPtr<CefCommandHandler> BrowserDummyClient::GetCommandHandler()
+{
+	return this;
+}
+
+CefRefPtr<CefRequestHandler> BrowserDummyClient::GetRequestHandler()
+{
+	return this;
+}
+
+CefRefPtr<CefLifeSpanHandler> BrowserDummyClient::GetLifeSpanHandler()
+{
+	return this;
+}
+
+bool BrowserDummyClient::OnChromeCommand(CefRefPtr<CefBrowser>, int, cef_window_open_disposition_t)
+{
+	return true;
+}
+
+bool BrowserDummyClient::IsChromeAppMenuItemVisible(CefRefPtr<CefBrowser>, int)
+{
+	return false;
+}
+
+bool BrowserDummyClient::IsChromeToolbarButtonVisible(cef_chrome_toolbar_button_type_t)
+{
+	return false;
+}
+
+bool BrowserDummyClient::IsChromePageActionIconVisible(cef_chrome_page_action_icon_type_t)
+{
+	return false;
+}
+
+bool BrowserDummyClient::IsChromeAppMenuItemEnabled(CefRefPtr<CefBrowser>, int)
+{
+	return false;
+}
+
+bool BrowserDummyClient::OnBeforePopup(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame>,
+#if CHROME_VERSION_BUILD >= 6834
+				       int,
+#endif
+				       const CefString &, const CefString &, cef_window_open_disposition_t, bool,
+				       const CefPopupFeatures &, CefWindowInfo &, CefRefPtr<CefClient> &,
+				       CefBrowserSettings &, CefRefPtr<CefDictionaryValue> &, bool *)
+{
+	return true;
+}
+
+void BrowserDummyClient::OnAfterCreated(CefRefPtr<CefBrowser> browser)
+{
+	if (browser && browser->GetHost()) {
+		browser->GetHost()->CloseBrowser(false);
+	}
+}
+
+bool BrowserDummyClient::OnOpenURLFromTab(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame>, const CefString &,
+					  CefRequestHandler::WindowOpenDisposition, bool)
+{
+	return true;
+}
+
+bool BrowserDummyClient::OnBeforeBrowse(CefRefPtr<CefBrowser>, CefRefPtr<CefFrame>, CefRefPtr<CefRequest>, bool, bool)
+{
+	return true;
+}

browser-dummy-client.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "cef-headers.hpp"
+
+class BrowserDummyClient : public CefClient,
+			   public CefCommandHandler,
+			   public CefRequestHandler,
+			   public CefLifeSpanHandler {
+public:
+	virtual CefRefPtr<CefCommandHandler> GetCommandHandler() override;
+	virtual CefRefPtr<CefRequestHandler> GetRequestHandler() override;
+	virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() override;
+
+	/* CefCommandHandler */
+	virtual bool OnChromeCommand(CefRefPtr<CefBrowser> browser, int command_id,
+				     cef_window_open_disposition_t disposition) override;
+	virtual bool IsChromeAppMenuItemVisible(CefRefPtr<CefBrowser> browser, int command_id) override;
+	virtual bool IsChromeToolbarButtonVisible(cef_chrome_toolbar_button_type_t button_type) override;
+
+	virtual bool IsChromePageActionIconVisible(cef_chrome_page_action_icon_type_t icon_type) override;
+
+	virtual bool IsChromeAppMenuItemEnabled(CefRefPtr<CefBrowser> browser, int command_id) override;
+
+	/* CefLifeSpanHandler */
+	virtual bool OnBeforePopup(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
+#if CHROME_VERSION_BUILD >= 6834
+				   int,
+#endif
+				   const CefString &target_url, const CefString &target_frame_name,
+				   cef_window_open_disposition_t target_disposition, bool user_gesture,
+				   const CefPopupFeatures &popupFeatures, CefWindowInfo &windowInfo,
+				   CefRefPtr<CefClient> &client, CefBrowserSettings &settings,
+				   CefRefPtr<CefDictionaryValue> &extra_info, bool *no_javascript_access) override;
+
+	virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) override;
+
+	/* CefRequestHandler */
+	virtual bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
+				      const CefString &target_url,
+				      CefRequestHandler::WindowOpenDisposition target_disposition,
+				      bool user_gesture) override;
+
+	virtual bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame,
+				    CefRefPtr<CefRequest> request, bool user_gesture, bool is_redirect) override;
+
+	IMPLEMENT_REFCOUNTING(BrowserDummyClient);
+};

cmake/os-linux.cmake

@@ -14,7 +14,8 @@ add_executable(OBS::browser-helper ALIAS browser-helper)
 
 target_sources(
   browser-helper PRIVATE # cmake-format: sortable
-                         browser-app.cpp browser-app.hpp cef-headers.hpp obs-browser-page/obs-browser-page-main.cpp)
+                         browser-app.cpp browser-app.hpp browser-dummy-client.hpp browser-dummy-client.cpp
+                         cef-headers.hpp obs-browser-page/obs-browser-page-main.cpp)
 
 target_include_directories(browser-helper PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/deps"
                                                   "${CMAKE_CURRENT_SOURCE_DIR}/obs-browser-page")

cmake/os-macos.cmake

@@ -31,7 +31,8 @@ foreach(helper IN LISTS helper_suffixes)
 
   target_sources(
     ${target_name} PRIVATE # cmake-format: sortable
-                           browser-app.cpp browser-app.hpp cef-headers.hpp obs-browser-page/obs-browser-page-main.cpp)
+                           browser-app.cpp browser-app.hpp browser-dummy-client.hpp browser-dummy-client.cpp
+                           cef-headers.hpp obs-browser-page/obs-browser-page-main.cpp)
 
   target_compile_definitions(${target_name} PRIVATE ENABLE_BROWSER_SHARED_TEXTURE)
 

cmake/os-windows.cmake

@@ -13,8 +13,8 @@ add_executable(OBS::browser-helper ALIAS obs-browser-helper)
 target_sources(
   obs-browser-helper
   PRIVATE # cmake-format: sortable
-          browser-app.cpp browser-app.hpp cef-headers.hpp obs-browser-page.manifest
-          obs-browser-page/obs-browser-page-main.cpp)
+          browser-app.cpp browser-app.hpp browser-dummy-client.hpp browser-dummy-client.cpp
+          cef-headers.hpp obs-browser-page.manifest obs-browser-page/obs-browser-page-main.cpp)
 
 configure_file(cmake/windows/obs-module-helper.rc.in obs-browser-page.rc)
 target_sources(obs-browser-helper PRIVATE obs-browser-page.rc)