Propagate RendererPreferences to SharedWorker

When starting a new shared worker, RendererPreferences is passed from the
browser to the renderer. This preference is used to reflect DNT header and
referrer for requests from shared workers.

Bug: 853085
Change-Id: Ie369a3ec513ffd16ba8a3f4b6a28061e6e1e83c0
Reviewed-on: https://chromium-review.googlesource.com/1135107
Commit-Queue: Makoto Shimazu <shimazu@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#576354}

content/browser/do_not_track_browsertest.cc

@@ -34,11 +34,30 @@ class MockContentBrowserClient final : public ContentBrowserClient {
 
 class DoNotTrackTest : public ContentBrowserTest {
  protected:
-  void EnableDoNotTrack() {
+  void TearDownOnMainThread() override {
+    if (original_client_)
+      SetBrowserClientForTesting(original_client_);
+  }
+
+  // Returns false if we cannot enable do not track. It happens only when
+  // Android Kitkat or older systems.
+  // TODO(crbug.com/864403): It seems that we call unsupported Android APIs on
+  // KitKat when we set a ContentBrowserClient. Don't call such APIs and make
+  // this test available on KitKat.
+  bool EnableDoNotTrack() {
+#if defined(OS_ANDROID)
+    int32_t major_version = 0, minor_version = 0, bugfix_version = 0;
+    base::SysInfo::OperatingSystemVersionNumbers(&major_version, &minor_version,
+                                                 &bugfix_version);
+    if (major_version < 5)
+      return false;
+#endif
+    original_client_ = SetBrowserClientForTesting(&client_);
     RendererPreferences* prefs =
         shell()->web_contents()->GetMutableRendererPrefs();
     EXPECT_FALSE(prefs->enable_do_not_track);
     prefs->enable_do_not_track = true;
+    return true;
   }
 
   void ExpectPageTextEq(const std::string& expected_content) {
@@ -59,6 +78,10 @@ class DoNotTrackTest : public ContentBrowserTest {
         &value));
     return value;
   }
+
+ private:
+  ContentBrowserClient* original_client_ = nullptr;
+  MockContentBrowserClient client_;
 };
 
 std::unique_ptr<net::test_server::HttpResponse> CaptureHeaderHandler(
@@ -88,7 +111,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, NotEnabled) {
 // Checks that the DNT header is sent when the corresponding preference is set.
 IN_PROC_BROWSER_TEST_F(DoNotTrackTest, Simple) {
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   GURL url = embedded_test_server()->GetURL("/echoheader?DNT");
   EXPECT_TRUE(NavigateToURL(shell(), url));
   ExpectPageTextEq("1");
@@ -100,7 +124,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, Redirect) {
   GURL final_url = embedded_test_server()->GetURL("/echoheader?DNT");
   GURL url = embedded_test_server()->GetURL(std::string("/server-redirect?") +
                                             final_url.spec());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   // We don't check the result NavigateToURL as it returns true only if the
   // final URL is equal to the passed URL.
   NavigateToURL(shell(), url);
@@ -111,7 +136,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, Redirect) {
 IN_PROC_BROWSER_TEST_F(DoNotTrackTest, DOMProperty) {
   ASSERT_TRUE(embedded_test_server()->Start());
   GURL url = embedded_test_server()->GetURL("/echo");
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   EXPECT_TRUE(NavigateToURL(shell(), url));
   EXPECT_EQ("1", GetDOMDoNotTrackProperty());
 }
@@ -124,7 +150,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, Worker) {
   embedded_test_server()->RegisterRequestHandler(base::BindRepeating(
       &CaptureHeaderHandler, "/capture", &header_map, loop.QuitClosure()));
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   const GURL url = embedded_test_server()->GetURL(
       std::string("/workers/create_worker.html?worker_url=/capture"));
   NavigateToURL(shell(), url);
@@ -143,7 +170,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, DISABLED_SharedWorker) {
   embedded_test_server()->RegisterRequestHandler(base::BindRepeating(
       &CaptureHeaderHandler, "/capture", &header_map, loop.QuitClosure()));
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   const GURL url = embedded_test_server()->GetURL(
       std::string("/workers/create_shared_worker.html?worker_url=/capture"));
   NavigateToURL(shell(), url);
@@ -162,7 +190,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, DISABLED_ServiceWorker) {
   embedded_test_server()->RegisterRequestHandler(base::BindRepeating(
       &CaptureHeaderHandler, "/capture", &header_map, loop.QuitClosure()));
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   const GURL url = embedded_test_server()->GetURL(std::string(
       "/service_worker/create_service_worker.html?worker_url=/capture"));
   NavigateToURL(shell(), url);
@@ -176,7 +205,8 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, DISABLED_ServiceWorker) {
 // worker.
 IN_PROC_BROWSER_TEST_F(DoNotTrackTest, FetchFromWorker) {
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   const GURL fetch_url = embedded_test_server()->GetURL("/echoheader?DNT");
   const GURL url = embedded_test_server()->GetURL(
       std::string("/workers/fetch_from_worker.html?url=") + fetch_url.spec());
@@ -190,10 +220,17 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, FetchFromWorker) {
 }
 
 // Checks that the DNT header is preserved when fetching from a shared worker.
-// Disabled due to crbug.com/853085.
-IN_PROC_BROWSER_TEST_F(DoNotTrackTest, DISABLED_FetchFromSharedWorker) {
+//
+// Disabled on Android since a shared worker is not available on Android.
+#if defined(OS_ANDROID)
+#define MAYBE_FetchFromSharedWorker DISABLED_FetchFromSharedWorker
+#else
+#define MAYBE_FetchFromSharedWorker FetchFromSharedWorker
+#endif
+IN_PROC_BROWSER_TEST_F(DoNotTrackTest, MAYBE_FetchFromSharedWorker) {
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   const GURL fetch_url = embedded_test_server()->GetURL("/echoheader?DNT");
   const GURL url = embedded_test_server()->GetURL(
       std::string("/workers/fetch_from_shared_worker.html?url=") +
@@ -209,21 +246,9 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, DISABLED_FetchFromSharedWorker) {
 
 // Checks that the DNT header is preserved when fetching from a service worker.
 IN_PROC_BROWSER_TEST_F(DoNotTrackTest, FetchFromServiceWorker) {
-#if defined(OS_ANDROID)
-  // TODO(crbug.com/864403): It seems that we call unsupported Android APIs on
-  // KitKat when we set a ContentBrowserClient. Don't call such APIs and make
-  // this test available on KitKat.
-  int32_t major_version = 0, minor_version = 0, bugfix_version = 0;
-  base::SysInfo::OperatingSystemVersionNumbers(&major_version, &minor_version,
-                                               &bugfix_version);
-  if (major_version < 5)
-    return;
-#endif
-  MockContentBrowserClient client;
-  ContentBrowserClient* original_client = SetBrowserClientForTesting(&client);
-
   ASSERT_TRUE(embedded_test_server()->Start());
-  EnableDoNotTrack();
+  if (!EnableDoNotTrack())
+    return;
   const GURL fetch_url = embedded_test_server()->GetURL("/echoheader?DNT");
   const GURL url = embedded_test_server()->GetURL(
       std::string("/service_worker/fetch_from_service_worker.html?url=") +
@@ -235,7 +260,6 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, FetchFromServiceWorker) {
   EXPECT_EQ(title, watcher.WaitAndGetTitle());
 
   ExpectPageTextEq("1");
-  SetBrowserClientForTesting(original_client);
 }
 
 }  // namespace

content/browser/shared_worker/mock_shared_worker.cc

@@ -98,6 +98,7 @@ void MockSharedWorkerFactory::CreateSharedWorker(
     mojom::SharedWorkerInfoPtr info,
     bool pause_on_start,
     const base::UnguessableToken& devtools_worker_token,
+    const RendererPreferences& renderer_preferences,
     blink::mojom::WorkerContentSettingsProxyPtr content_settings,
     mojom::ServiceWorkerProviderInfoForSharedWorkerPtr
         service_worker_provider_info,

content/browser/shared_worker/mock_shared_worker.h

@@ -67,6 +67,7 @@ class MockSharedWorkerFactory : public mojom::SharedWorkerFactory {
       mojom::SharedWorkerInfoPtr info,
       bool pause_on_start,
       const base::UnguessableToken& devtools_worker_token,
+      const RendererPreferences& renderer_preferences,
       blink::mojom::WorkerContentSettingsProxyPtr content_settings,
       mojom::ServiceWorkerProviderInfoForSharedWorkerPtr
           service_worker_provider_info,

content/browser/shared_worker/shared_worker_host.cc

@@ -141,6 +141,11 @@ void SharedWorkerHost::Start(
   devtools_handle_ = std::make_unique<ScopedDevToolsHandle>(
       this, &pause_on_start, &devtools_worker_token);
 
+  RendererPreferences renderer_preferences;
+  GetContentClient()->browser()->UpdateRendererPreferencesForWorker(
+      RenderProcessHost::FromID(process_id_)->GetBrowserContext(),
+      &renderer_preferences);
+
   // Set up content settings interface.
   blink::mojom::WorkerContentSettingsProxyPtr content_settings;
   content_settings_ = std::make_unique<SharedWorkerContentSettingsProxyImpl>(
@@ -183,9 +188,9 @@ void SharedWorkerHost::Start(
   factory_ = std::move(factory);
   factory_->CreateSharedWorker(
       std::move(info), pause_on_start, devtools_worker_token,
-      std::move(content_settings), std::move(service_worker_provider_info),
-      std::move(script_loader_factory), std::move(factory_bundle),
-      std::move(host), std::move(worker_request_),
+      renderer_preferences, std::move(content_settings),
+      std::move(service_worker_provider_info), std::move(script_loader_factory),
+      std::move(factory_bundle), std::move(host), std::move(worker_request_),
       std::move(interface_provider));
 
   // Monitor the lifetime of the worker.

content/browser/shared_worker/shared_worker_host_unittest.cc

@@ -14,6 +14,8 @@
 #include "content/browser/shared_worker/shared_worker_connector_impl.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
+#include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_storage_partition.h"
 #include "content/public/test/test_utils.h"
@@ -31,7 +33,8 @@ namespace content {
 class SharedWorkerHostTest : public testing::Test {
  public:
   SharedWorkerHostTest()
-      : service_(&storage_partition_, nullptr /* service_worker_context */) {
+      : mock_render_process_host_(&browser_context_),
+        service_(&storage_partition_, nullptr /* service_worker_context */) {
     storage_partition_.set_network_context(&network_context_);
   }
 
@@ -52,7 +55,7 @@ class SharedWorkerHostTest : public testing::Test {
         content_security_policy_type, creation_address_space,
         creation_context_type);
     auto host = std::make_unique<SharedWorkerHost>(
-        &service_, std::move(instance), 11 /* dummy process_id */);
+        &service_, std::move(instance), mock_render_process_host_.GetID());
     auto weak_host = host->AsWeakPtr();
     service_.worker_hosts_.insert(std::move(host));
     return weak_host;
@@ -79,6 +82,8 @@ class SharedWorkerHostTest : public testing::Test {
   TestBrowserThreadBundle test_browser_thread_bundle_;
   TestStoragePartition storage_partition_;
   network::TestNetworkContext network_context_;
+  TestBrowserContext browser_context_;
+  MockRenderProcessHost mock_render_process_host_;
 
   SharedWorkerServiceImpl service_;
 

content/common/shared_worker/shared_worker_factory.mojom

@@ -4,6 +4,7 @@
 
 module content.mojom;
 
+import "content/common/native_types.mojom";
 import "content/common/service_worker/service_worker_provider.mojom";
 import "content/common/shared_worker/shared_worker.mojom";
 import "content/common/shared_worker/shared_worker_host.mojom";
@@ -31,6 +32,7 @@ interface SharedWorkerFactory {
       SharedWorkerInfo info,
       bool pause_on_start,
       mojo_base.mojom.UnguessableToken devtools_worker_token,
+      RendererPreferences renderer_preferences,
       blink.mojom.WorkerContentSettingsProxy content_settings,
 
       // S13nServiceWorker:

content/renderer/shared_worker/embedded_shared_worker_stub.cc

@@ -194,6 +194,7 @@ EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
     mojom::SharedWorkerInfoPtr info,
     bool pause_on_start,
     const base::UnguessableToken& devtools_worker_token,
+    const RendererPreferences& renderer_preferences,
     blink::mojom::WorkerContentSettingsProxyPtr content_settings,
     mojom::ServiceWorkerProviderInfoForSharedWorkerPtr
         service_worker_provider_info,
@@ -206,7 +207,8 @@ EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
     : binding_(this, std::move(request)),
       host_(std::move(host)),
       name_(info->name),
-      url_(info->url) {
+      url_(info->url),
+      renderer_preferences_(renderer_preferences) {
   impl_ = blink::WebSharedWorker::Create(this);
   if (pause_on_start) {
     // Pause worker context when it starts and wait until either DevTools client
@@ -375,11 +377,8 @@ EmbeddedSharedWorkerStub::CreateWorkerFetchContext(
   std::unique_ptr<network::SharedURLLoaderFactoryInfo> fallback_factory =
       loader_factories_->Clone();
 
-  // TODO(crbug.com/853085): Send the preference from the browser process.
-  RendererPreferences renderer_preferences;
-
   auto worker_fetch_context = std::make_unique<WebWorkerFetchContextImpl>(
-      std::move(renderer_preferences), std::move(worker_client_request),
+      std::move(renderer_preferences_), std::move(worker_client_request),
       std::move(worker_client_registry_ptr_info),
       std::move(container_host_ptr_info), loader_factories_->Clone(),
       std::move(fallback_factory),

content/renderer/shared_worker/embedded_shared_worker_stub.h

@@ -15,6 +15,7 @@
 #include "content/common/shared_worker/shared_worker.mojom.h"
 #include "content/common/shared_worker/shared_worker_host.mojom.h"
 #include "content/common/shared_worker/shared_worker_info.mojom.h"
+#include "content/public/common/renderer_preferences.h"
 #include "ipc/ipc_listener.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
@@ -59,6 +60,7 @@ class EmbeddedSharedWorkerStub : public blink::WebSharedWorkerClient,
       mojom::SharedWorkerInfoPtr info,
       bool pause_on_start,
       const base::UnguessableToken& devtools_worker_token,
+      const RendererPreferences& renderer_preferences,
       blink::mojom::WorkerContentSettingsProxyPtr content_settings,
       mojom::ServiceWorkerProviderInfoForSharedWorkerPtr
           service_worker_provider_info,
@@ -106,6 +108,7 @@ class EmbeddedSharedWorkerStub : public blink::WebSharedWorkerClient,
   const std::string name_;
   bool running_ = false;
   GURL url_;
+  RendererPreferences renderer_preferences_;
   std::unique_ptr<blink::WebSharedWorker> impl_;
 
   using PendingChannel =

content/renderer/shared_worker/shared_worker_factory_impl.cc

@@ -24,6 +24,7 @@ void SharedWorkerFactoryImpl::CreateSharedWorker(
     mojom::SharedWorkerInfoPtr info,
     bool pause_on_start,
     const base::UnguessableToken& devtools_worker_token,
+    const RendererPreferences& renderer_preferences,
     blink::mojom::WorkerContentSettingsProxyPtr content_settings,
     mojom::ServiceWorkerProviderInfoForSharedWorkerPtr
         service_worker_provider_info,
@@ -36,7 +37,8 @@ void SharedWorkerFactoryImpl::CreateSharedWorker(
   // Bound to the lifetime of the underlying blink::WebSharedWorker instance.
   new EmbeddedSharedWorkerStub(
       std::move(info), pause_on_start, devtools_worker_token,
-      std::move(content_settings), std::move(service_worker_provider_info),
+      renderer_preferences, std::move(content_settings),
+      std::move(service_worker_provider_info),
       std::move(script_loader_factory_ptr_info), std::move(subresource_loaders),
       std::move(host), std::move(request), std::move(interface_provider));
 }

content/renderer/shared_worker/shared_worker_factory_impl.h

@@ -25,6 +25,7 @@ class SharedWorkerFactoryImpl : public mojom::SharedWorkerFactory {
       mojom::SharedWorkerInfoPtr info,
       bool pause_on_start,
       const base::UnguessableToken& devtools_worker_token,
+      const RendererPreferences& renderer_preferences,
       blink::mojom::WorkerContentSettingsProxyPtr content_settings,
       mojom::ServiceWorkerProviderInfoForSharedWorkerPtr
           service_worker_provider_info,