[WebLayer] Sync content settings to renderer

This implements TabSpecificContentSettings for weblayer, and syncs
content settings to the renderer similar to what is done for chrome. A
couple client hints tests are added which depend on the content settings
syncing behavior to make sure it's working.

Bug: 1070825, 1065537
Change-Id: I72946341ae8e0932663ffb1ef72954b0a7897b1a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2153314Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Robert Sesek <rsesek@chromium.org>
Commit-Queue: Clark DuVall <cduvall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#760177}

weblayer/BUILD.gn

@@ -101,6 +101,13 @@ if (is_android) {
   }
 }
 
+mojom("common_mojom") {
+  disable_variants = true
+
+  sources = [ "common/renderer_configuration.mojom" ]
+  deps = [ "//components/content_settings/core/common:mojo_bindings" ]
+}
+
 source_set("weblayer_lib_base") {
   sources = [
     "app/content_main_delegate_impl.cc",
@@ -172,6 +179,8 @@ source_set("weblayer_lib_base") {
     "browser/system_network_context_manager.h",
     "browser/tab_impl.cc",
     "browser/tab_impl.h",
+    "browser/tab_specific_content_settings_delegate.cc",
+    "browser/tab_specific_content_settings_delegate.h",
     "browser/url_bar/autocomplete_scheme_classifier_impl.cc",
     "browser/url_bar/autocomplete_scheme_classifier_impl.h",
     "browser/url_bar/url_bar_controller_impl.cc",
@@ -223,6 +232,8 @@ source_set("weblayer_lib_base") {
     "renderer/error_page_helper.h",
     "renderer/weblayer_render_frame_observer.cc",
     "renderer/weblayer_render_frame_observer.h",
+    "renderer/weblayer_render_thread_observer.cc",
+    "renderer/weblayer_render_thread_observer.h",
     "utility/content_utility_client_impl.cc",
     "utility/content_utility_client_impl.h",
   ]
@@ -236,6 +247,7 @@ source_set("weblayer_lib_base") {
 
   public_deps = [ ":android_descriptors" ]
   deps = [
+    ":common_mojom",
     "//base",
     "//base:base_static",
     "//base/third_party/dynamic_annotations",
@@ -247,6 +259,8 @@ source_set("weblayer_lib_base") {
     "//components/captive_portal/core:buildflags",
     "//components/cdm/renderer",
     "//components/client_hints/browser",
+    "//components/content_settings/browser",
+    "//components/content_settings/common:mojom",
     "//components/content_settings/common:mojom",
     "//components/content_settings/core/browser",
     "//components/content_settings/renderer",
@@ -269,6 +283,7 @@ source_set("weblayer_lib_base") {
     "//components/security_interstitials/content/renderer:security_interstitial_page_controller",
     "//components/security_interstitials/core",
     "//components/security_state/content",
+    "//components/services/storage/public/mojom",
     "//components/sessions",
     "//components/spellcheck:buildflags",
     "//components/ssl_errors",

weblayer/browser/DEPS

@@ -9,6 +9,7 @@ include_rules = [
   "+components/captive_portal",
   "+components/cdm/browser",
   "+components/client_hints/browser",
+  "+components/content_settings/browser",
   "+components/content_settings/common",
   "+components/content_settings/core/common",
   "+components/crash/content/browser",

weblayer/browser/browser_context_impl.cc

@@ -18,6 +18,7 @@
 #include "components/prefs/pref_service_factory.h"
 #include "components/safe_browsing/core/common/safe_browsing_prefs.h"
 #include "components/security_interstitials/content/stateful_ssl_host_state_delegate.h"
+#include "components/security_state/core/security_state.h"
 #include "components/user_prefs/user_prefs.h"
 #include "components/variations/variations_client.h"
 #include "components/variations/variations_http_header_provider.h"
@@ -233,6 +234,7 @@ void BrowserContextImpl::RegisterPrefs(
   StatefulSSLHostStateDelegate::RegisterProfilePrefs(pref_registry);
   HostContentSettingsMap::RegisterProfilePrefs(pref_registry);
   safe_browsing::RegisterProfilePrefs(pref_registry);
+  security_state::RegisterProfilePrefs(pref_registry);
 #if defined(OS_ANDROID)
   cdm::MediaDrmStorageImpl::RegisterProfilePrefs(pref_registry);
   permissions::GeolocationPermissionContextAndroid::RegisterProfilePrefs(

weblayer/browser/client_hints_browsertest.cc

@@ -3,9 +3,13 @@
 // found in the LICENSE file.
 
 #include "base/strings/string_number_conversions.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "content/public/browser/render_process_host.h"
 #include "content/public/test/browser_test_utils.h"
+#include "net/test/embedded_test_server/default_handlers.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "weblayer/browser/browser_process.h"
+#include "weblayer/browser/host_content_settings_map_factory.h"
 #include "weblayer/browser/tab_impl.h"
 #include "weblayer/shell/browser/shell.h"
 #include "weblayer/test/weblayer_browser_test.h"
@@ -21,6 +25,73 @@ class ClientHintsBrowserTest : public WebLayerBrowserTest {
         ->GetNetworkQualityTracker()
         ->ReportRTTsAndThroughputForTesting(
             base::TimeDelta::FromMilliseconds(500), 100);
+
+    EXPECT_TRUE(embedded_test_server()->Start());
+  }
+
+  void SetAcceptClientHints() {
+    NavigateAndWaitForCompletion(
+        embedded_test_server()->GetURL(
+            "/set-header?Accept-CH: device-memory,rtt&Accept-CH-Lifetime: "
+            "86400"),
+        shell());
+  }
+
+  void CheckNavigationHeaders() {
+    NavigateAndWaitForCompletion(
+        embedded_test_server()->GetURL("/echoheader?device-memory"), shell());
+
+    double device_memory = 0.0;
+    ASSERT_TRUE(base::StringToDouble(GetBody(), &device_memory));
+    EXPECT_GT(device_memory, 0.0);
+
+    NavigateAndWaitForCompletion(
+        embedded_test_server()->GetURL("/echoheader?rtt"), shell());
+    int rtt = 0;
+    ASSERT_TRUE(base::StringToInt(GetBody(), &rtt));
+    EXPECT_GT(rtt, 0);
+  }
+
+  void CheckSubresourceHeaders() {
+    double device_memory = 0.0;
+    ASSERT_TRUE(base::StringToDouble(GetSubresourceHeader("device-memory"),
+                                     &device_memory));
+    EXPECT_GT(device_memory, 0.0);
+
+    int rtt = 0;
+    ASSERT_TRUE(base::StringToInt(GetSubresourceHeader("rtt"), &rtt));
+    EXPECT_GT(rtt, 0);
+  }
+
+  void KillRenderer() {
+    content::RenderProcessHost* child_process =
+        static_cast<TabImpl*>(shell()->tab())
+            ->web_contents()
+            ->GetMainFrame()
+            ->GetProcess();
+    content::RenderProcessHostWatcher crash_observer(
+        child_process,
+        content::RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT);
+    child_process->Shutdown(0);
+    crash_observer.Wait();
+  }
+
+  std::string GetSubresourceHeader(const std::string& header) {
+    constexpr char kScript[] = R"(
+      new Promise(function (resolve, reject) {
+        const xhr = new XMLHttpRequest();
+        xhr.open("GET", "/echoheader?" + $1);
+        xhr.onload = () => {
+          resolve(xhr.response);
+        };
+        xhr.send();
+      })
+    )";
+    content::WebContents* web_contents =
+        static_cast<TabImpl*>(shell()->tab())->web_contents();
+    return content::EvalJs(web_contents,
+                           content::JsReplace(kScript, "device-memory"))
+        .ExtractString();
   }
 
   std::string GetBody() {
@@ -29,59 +100,50 @@ class ClientHintsBrowserTest : public WebLayerBrowserTest {
 };
 
 IN_PROC_BROWSER_TEST_F(ClientHintsBrowserTest, Navigation) {
-  EXPECT_TRUE(embedded_test_server()->Start());
-  NavigateAndWaitForCompletion(
-      embedded_test_server()->GetURL(
-          "/set-header?Accept-CH: device-memory,rtt&Accept-CH-Lifetime: 86400"),
-      shell());
-
-  NavigateAndWaitForCompletion(
-      embedded_test_server()->GetURL("/echoheader?device-memory"), shell());
-
-  double device_memory = 0.0;
-  ASSERT_TRUE(base::StringToDouble(GetBody(), &device_memory));
-  EXPECT_GT(device_memory, 0.0);
-
-  NavigateAndWaitForCompletion(
-      embedded_test_server()->GetURL("/echoheader?rtt"), shell());
-  int rtt = 0;
-  ASSERT_TRUE(base::StringToInt(GetBody(), &rtt));
-  EXPECT_GT(rtt, 0);
+  SetAcceptClientHints();
+  CheckNavigationHeaders();
 }
 
 IN_PROC_BROWSER_TEST_F(ClientHintsBrowserTest, Subresource) {
-  EXPECT_TRUE(embedded_test_server()->Start());
-  NavigateAndWaitForCompletion(
-      embedded_test_server()->GetURL(
-          "/set-header?Accept-CH: device-memory,rtt&Accept-CH-Lifetime: 86400"),
-      shell());
-
-  constexpr char kScript[] = R"(
-    new Promise(function (resolve, reject) {
-      const xhr = new XMLHttpRequest();
-      xhr.open("GET", "/echoheader?" + $1);
-      xhr.onload = () => {
-        resolve(xhr.response);
-      };
-      xhr.send();
-    })
-  )";
-  content::WebContents* web_contents =
-      static_cast<TabImpl*>(shell()->tab())->web_contents();
-  double device_memory = 0.0;
-  ASSERT_TRUE(base::StringToDouble(
-      content::EvalJs(web_contents,
-                      content::JsReplace(kScript, "device-memory"))
-          .ExtractString(),
-      &device_memory));
-  EXPECT_GT(device_memory, 0.0);
-
-  int rtt = 0;
-  ASSERT_TRUE(base::StringToInt(
-      content::EvalJs(web_contents, content::JsReplace(kScript, "rtt"))
-          .ExtractString(),
-      &rtt));
-  EXPECT_GT(rtt, 0);
+  SetAcceptClientHints();
+  CheckSubresourceHeaders();
+}
+
+IN_PROC_BROWSER_TEST_F(ClientHintsBrowserTest, SubresourceInNewRenderer) {
+  SetAcceptClientHints();
+  KillRenderer();
+  NavigateAndWaitForCompletion(embedded_test_server()->GetURL("/echo"),
+                               shell());
+  CheckSubresourceHeaders();
+}
+
+IN_PROC_BROWSER_TEST_F(ClientHintsBrowserTest,
+                       SubresourceAfterContentSettingUpdate) {
+  // Set accept client hints on the original server.
+  SetAcceptClientHints();
+
+  // Start a new server which will not accept client hints.
+  net::test_server::EmbeddedTestServer other_server;
+  net::test_server::RegisterDefaultHandlers(&other_server);
+  ASSERT_TRUE(other_server.Start());
+  NavigateAndWaitForCompletion(other_server.GetURL("/echo"), shell());
+  EXPECT_EQ(GetSubresourceHeader("device-memory"), "None");
+
+  // Copy client hints over to the other server.
+  auto* settings_map = HostContentSettingsMapFactory::GetForBrowserContext(
+      static_cast<TabImpl*>(shell()->tab())
+          ->web_contents()
+          ->GetBrowserContext());
+  std::unique_ptr<base::Value> setting = settings_map->GetWebsiteSetting(
+      embedded_test_server()->base_url(), GURL(),
+      ContentSettingsType::CLIENT_HINTS, std::string(), nullptr);
+  ASSERT_TRUE(setting);
+  settings_map->SetWebsiteSettingDefaultScope(
+      other_server.base_url(), GURL(), ContentSettingsType::CLIENT_HINTS,
+      std::string(), std::make_unique<base::Value>(setting->Clone()));
+
+  // New server should now get client hints.
+  CheckSubresourceHeaders();
 }
 
 }  // namespace weblayer

weblayer/browser/content_browser_client_impl.cc

@@ -60,6 +60,7 @@
 #include "weblayer/browser/profile_impl.h"
 #include "weblayer/browser/system_network_context_manager.h"
 #include "weblayer/browser/tab_impl.h"
+#include "weblayer/browser/tab_specific_content_settings_delegate.h"
 #include "weblayer/browser/web_contents_view_delegate_impl.h"
 #include "weblayer/browser/weblayer_browser_interface_binders.h"
 #include "weblayer/browser/weblayer_content_browser_overlay_manifest.h"
@@ -567,6 +568,7 @@ void ContentBrowserClientImpl::RenderProcessWillLaunch(
       /*can_persist_data*/ true,
       /*force_to_support_secure_codecs*/ false));
 #endif
+  TabSpecificContentSettingsDelegate::UpdateRendererContentSettingRules(host);
 }
 
 scoped_refptr<content::QuotaPermissionContext>

weblayer/browser/tab_impl.cc

@@ -13,6 +13,7 @@
 #include "components/autofill/core/browser/autofill_provider.h"
 #include "components/captive_portal/core/buildflags.h"
 #include "components/client_hints/browser/client_hints.h"
+#include "components/content_settings/browser/tab_specific_content_settings.h"
 #include "components/find_in_page/find_tab_helper.h"
 #include "components/find_in_page/find_types.h"
 #include "components/permissions/permission_manager.h"
@@ -41,6 +42,7 @@
 #include "weblayer/browser/permissions/permission_manager_factory.h"
 #include "weblayer/browser/persistence/browser_persister.h"
 #include "weblayer/browser/profile_impl.h"
+#include "weblayer/browser/tab_specific_content_settings_delegate.h"
 #include "weblayer/common/isolated_world_ids.h"
 #include "weblayer/public/fullscreen_delegate.h"
 #include "weblayer/public/new_tab_delegate.h"
@@ -219,6 +221,9 @@ TabImpl::TabImpl(ProfileImpl* profile,
       HostContentSettingsMapFactory::GetForBrowserContext(
           web_contents_->GetBrowserContext()),
       GetUserAgentMetadata());
+  content_settings::TabSpecificContentSettings::CreateForWebContents(
+      web_contents_.get(), std::make_unique<TabSpecificContentSettingsDelegate>(
+                               web_contents_.get()));
 
 #if defined(OS_ANDROID)
   javascript_dialogs::TabModalDialogManager::CreateForWebContents(

weblayer/browser/tab_specific_content_settings_delegate.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "weblayer/browser/tab_specific_content_settings_delegate.h"
+
+#include "components/content_settings/core/common/content_settings.h"
+#include "content/public/browser/render_process_host.h"
+#include "weblayer/browser/browser_context_impl.h"
+#include "weblayer/browser/host_content_settings_map_factory.h"
+#include "weblayer/common/renderer_configuration.mojom.h"
+
+namespace weblayer {
+namespace {
+
+void SetContentSettingRules(content::RenderProcessHost* process,
+                            const RendererContentSettingRules& rules) {
+  mojo::AssociatedRemote<mojom::RendererConfiguration> rc_interface;
+  process->GetChannel()->GetRemoteAssociatedInterface(&rc_interface);
+  rc_interface->SetContentSettingRules(rules);
+}
+
+}  // namespace
+
+TabSpecificContentSettingsDelegate::TabSpecificContentSettingsDelegate(
+    content::WebContents* web_contents)
+    : web_contents_(web_contents) {}
+
+TabSpecificContentSettingsDelegate::~TabSpecificContentSettingsDelegate() =
+    default;
+
+// static
+void TabSpecificContentSettingsDelegate::UpdateRendererContentSettingRules(
+    content::RenderProcessHost* process) {
+  RendererContentSettingRules rules;
+  GetRendererContentSettingRules(
+      HostContentSettingsMapFactory::GetForBrowserContext(
+          process->GetBrowserContext()),
+      &rules);
+  weblayer::SetContentSettingRules(process, rules);
+}
+
+void TabSpecificContentSettingsDelegate::UpdateLocationBar() {}
+
+void TabSpecificContentSettingsDelegate::SetContentSettingRules(
+    content::RenderProcessHost* process,
+    const RendererContentSettingRules& rules) {
+  weblayer::SetContentSettingRules(process, rules);
+}
+
+PrefService* TabSpecificContentSettingsDelegate::GetPrefs() {
+  return static_cast<BrowserContextImpl*>(web_contents_->GetBrowserContext())
+      ->pref_service();
+}
+
+HostContentSettingsMap* TabSpecificContentSettingsDelegate::GetSettingsMap() {
+  return HostContentSettingsMapFactory::GetForBrowserContext(
+      web_contents_->GetBrowserContext());
+}
+
+std::vector<storage::FileSystemType>
+TabSpecificContentSettingsDelegate::GetAdditionalFileSystemTypes() {
+  return {};
+}
+
+bool TabSpecificContentSettingsDelegate::IsMicrophoneCameraStateChanged(
+    content_settings::TabSpecificContentSettings::MicrophoneCameraState
+        microphone_camera_state,
+    const std::string& media_stream_selected_audio_device,
+    const std::string& media_stream_selected_video_device) {
+  return false;
+}
+
+content_settings::TabSpecificContentSettings::MicrophoneCameraState
+TabSpecificContentSettingsDelegate::GetMicrophoneCameraState() {
+  return content_settings::TabSpecificContentSettings::
+      MICROPHONE_CAMERA_NOT_ACCESSED;
+}
+
+void TabSpecificContentSettingsDelegate::OnContentBlocked(
+    ContentSettingsType type) {}
+
+}  // namespace weblayer

weblayer/browser/tab_specific_content_settings_delegate.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef WEBLAYER_BROWSER_TAB_SPECIFIC_CONTENT_SETTINGS_DELEGATE_H_
+#define WEBLAYER_BROWSER_TAB_SPECIFIC_CONTENT_SETTINGS_DELEGATE_H_
+
+#include "components/content_settings/browser/tab_specific_content_settings.h"
+
+namespace weblayer {
+
+// Called by TabSpecificContentSettings to handle WebLayer specific logic.
+class TabSpecificContentSettingsDelegate
+    : public content_settings::TabSpecificContentSettings::Delegate {
+ public:
+  explicit TabSpecificContentSettingsDelegate(
+      content::WebContents* web_contents);
+  ~TabSpecificContentSettingsDelegate() override;
+  TabSpecificContentSettingsDelegate(
+      const TabSpecificContentSettingsDelegate&) = delete;
+  TabSpecificContentSettingsDelegate& operator=(
+      const TabSpecificContentSettingsDelegate&) = delete;
+
+  static void UpdateRendererContentSettingRules(
+      content::RenderProcessHost* process);
+
+ private:
+  // TabSpecificContentSettings::Delegate:
+  void UpdateLocationBar() override;
+  void SetContentSettingRules(
+      content::RenderProcessHost* process,
+      const RendererContentSettingRules& rules) override;
+  PrefService* GetPrefs() override;
+  HostContentSettingsMap* GetSettingsMap() override;
+  std::vector<storage::FileSystemType> GetAdditionalFileSystemTypes() override;
+  bool IsMicrophoneCameraStateChanged(
+      content_settings::TabSpecificContentSettings::MicrophoneCameraState
+          microphone_camera_state,
+      const std::string& media_stream_selected_audio_device,
+      const std::string& media_stream_selected_video_device) override;
+  content_settings::TabSpecificContentSettings::MicrophoneCameraState
+  GetMicrophoneCameraState() override;
+  void OnContentBlocked(ContentSettingsType type) override;
+
+  content::WebContents* web_contents_;
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_TAB_SPECIFIC_CONTENT_SETTINGS_DELEGATE_H_

weblayer/common/OWNERS

+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS

weblayer/common/renderer_configuration.mojom

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+module weblayer.mojom;
+
+import "components/content_settings/core/common/content_settings.mojom";
+
+// Configures the renderer.
+interface RendererConfiguration {
+  // Set the content setting rules stored by the renderer.
+  SetContentSettingRules(
+      content_settings.mojom.RendererContentSettingRules rules);
+};

weblayer/renderer/content_renderer_client_impl.cc

@@ -14,6 +14,7 @@
 #include "weblayer/common/features.h"
 #include "weblayer/renderer/error_page_helper.h"
 #include "weblayer/renderer/weblayer_render_frame_observer.h"
+#include "weblayer/renderer/weblayer_render_thread_observer.h"
 
 #if defined(OS_ANDROID)
 #include "components/android_system_error_page/error_page_populator.h"
@@ -64,6 +65,10 @@ void ContentRendererClientImpl::RenderThreadStarted() {
   }
 #endif
 
+  content::RenderThread* thread = content::RenderThread::Get();
+  weblayer_observer_ = std::make_unique<WebLayerRenderThreadObserver>();
+  thread->AddObserver(weblayer_observer_.get());
+
   browser_interface_broker_ =
       blink::Platform::Current()->GetBrowserInterfaceBroker();
 }
@@ -79,9 +84,11 @@ void ContentRendererClientImpl::RenderFrameCreated(
           render_frame, render_frame_observer->associated_interfaces());
   new autofill::AutofillAgent(render_frame, password_autofill_agent, nullptr,
                               render_frame_observer->associated_interfaces());
-  new content_settings::ContentSettingsAgentImpl(
+  auto* agent = new content_settings::ContentSettingsAgentImpl(
       render_frame, false /* should_whitelist */,
       std::make_unique<content_settings::ContentSettingsAgentImpl::Delegate>());
+  if (weblayer_observer_)
+    agent->SetContentSettingRules(weblayer_observer_->content_setting_rules());
 
 #if defined(OS_ANDROID)
   // |SpellCheckProvider| manages its own lifetime (and destroys itself when the

weblayer/renderer/content_renderer_client_impl.h

@@ -17,6 +17,7 @@ class LocalInterfaceProvider;
 }  // namespace service_manager
 
 namespace weblayer {
+class WebLayerRenderThreadObserver;
 
 class ContentRendererClientImpl : public content::ContentRendererClient {
  public:
@@ -45,6 +46,8 @@ class ContentRendererClientImpl : public content::ContentRendererClient {
   std::unique_ptr<SpellCheck> spellcheck_;
 #endif
 
+  std::unique_ptr<WebLayerRenderThreadObserver> weblayer_observer_;
+
   scoped_refptr<blink::ThreadSafeBrowserInterfaceBrokerProxy>
       browser_interface_broker_;
 

weblayer/renderer/weblayer_render_thread_observer.cc

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "weblayer/renderer/weblayer_render_thread_observer.h"
+
+#include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
+
+namespace weblayer {
+
+WebLayerRenderThreadObserver::WebLayerRenderThreadObserver() = default;
+
+WebLayerRenderThreadObserver::~WebLayerRenderThreadObserver() = default;
+
+void WebLayerRenderThreadObserver::RegisterMojoInterfaces(
+    blink::AssociatedInterfaceRegistry* associated_interfaces) {
+  associated_interfaces->AddInterface(base::BindRepeating(
+      &WebLayerRenderThreadObserver::OnRendererConfigurationAssociatedRequest,
+      base::Unretained(this)));
+}
+
+void WebLayerRenderThreadObserver::UnregisterMojoInterfaces(
+    blink::AssociatedInterfaceRegistry* associated_interfaces) {
+  associated_interfaces->RemoveInterface(mojom::RendererConfiguration::Name_);
+}
+
+// weblayer::mojom::RendererConfiguration:
+void WebLayerRenderThreadObserver::SetContentSettingRules(
+    const RendererContentSettingRules& rules) {
+  content_setting_rules_ = rules;
+}
+
+void WebLayerRenderThreadObserver::OnRendererConfigurationAssociatedRequest(
+    mojo::PendingAssociatedReceiver<mojom::RendererConfiguration> receiver) {
+  renderer_configuration_receivers_.Add(this, std::move(receiver));
+}
+
+}  // namespace weblayer

weblayer/renderer/weblayer_render_thread_observer.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef WEBLAYER_RENDERER_WEBLAYER_RENDER_THREAD_OBSERVER_H_
+#define WEBLAYER_RENDERER_WEBLAYER_RENDER_THREAD_OBSERVER_H_
+
+#include "content/public/renderer/render_thread_observer.h"
+#include "mojo/public/cpp/bindings/associated_receiver_set.h"
+#include "weblayer/common/renderer_configuration.mojom.h"
+
+namespace weblayer {
+
+// Listens for WebLayer-specific messages from the browser.
+class WebLayerRenderThreadObserver : public content::RenderThreadObserver,
+                                     public mojom::RendererConfiguration {
+ public:
+  WebLayerRenderThreadObserver();
+  ~WebLayerRenderThreadObserver() override;
+
+  const RendererContentSettingRules* content_setting_rules() const {
+    return &content_setting_rules_;
+  }
+
+ private:
+  // content::RenderThreadObserver:
+  void RegisterMojoInterfaces(
+      blink::AssociatedInterfaceRegistry* associated_interfaces) override;
+  void UnregisterMojoInterfaces(
+      blink::AssociatedInterfaceRegistry* associated_interfaces) override;
+
+  // weblayer::mojom::RendererConfiguration:
+  void SetContentSettingRules(
+      const RendererContentSettingRules& rules) override;
+
+  void OnRendererConfigurationAssociatedRequest(
+      mojo::PendingAssociatedReceiver<mojom::RendererConfiguration> receiver);
+
+  RendererContentSettingRules content_setting_rules_;
+
+  mojo::AssociatedReceiverSet<mojom::RendererConfiguration>
+      renderer_configuration_receivers_;
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_RENDERER_WEBLAYER_RENDER_THREAD_OBSERVER_H_