Limit Link header based SW installations for fetches made by SW.

content/browser/service_worker/link_header_support_unittest.cc

 // Copyright 2016 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 "content/browser/service_worker/link_header_support.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ skipping 16 matching lines @@
 ServiceWorkerContextWrapper::GetRegistrationsInfosCallback
 SaveFoundRegistrations(
     ServiceWorkerStatusCode expected_status,
     bool* called,
     std::vector<ServiceWorkerRegistrationInfo>* registrations) {
   *called = false;
   return base::Bind(&SaveFoundRegistrationsCallback, expected_status, called,
                     registrations);
 }
 
+}  // namespace
+
 class LinkHeaderServiceWorkerTest : public ::testing::Test {
  public:
   LinkHeaderServiceWorkerTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         resource_context_(&request_context_) {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kEnableExperimentalWebPlatformFeatures);
   }
   ~LinkHeaderServiceWorkerTest() override {}
 
   void SetUp() override {
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
 
     // An empty host.
     std::unique_ptr<ServiceWorkerProviderHost> host(
         new ServiceWorkerProviderHost(
-            helper_->mock_render_process_id(), MSG_ROUTING_NONE,
-            kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+            render_process_id(), MSG_ROUTING_NONE, kMockProviderId,
+            SERVICE_WORKER_PROVIDER_FOR_WINDOW,
             ServiceWorkerProviderHost::FrameSecurityLevel::UNINITIALIZED,
             context()->AsWeakPtr(), nullptr));
     provider_host_ = host->AsWeakPtr();
     context()->AddProviderHost(std::move(host));
   }
 
   void TearDown() override { helper_.reset(); }
 
   ServiceWorkerContextCore* context() { return helper_->context(); }
   ServiceWorkerContextWrapper* context_wrapper() {
     return helper_->context_wrapper();
   }
   ServiceWorkerProviderHost* provider_host() { return provider_host_.get(); }
+  int render_process_id() const { return helper_->mock_render_process_id(); }
+
+  void CreateServiceWorkerProviderHost() {
+    std::unique_ptr<ServiceWorkerProviderHost> host(
+        new ServiceWorkerProviderHost(
+            render_process_id(), MSG_ROUTING_NONE, kMockProviderId,
+            SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
+            ServiceWorkerProviderHost::FrameSecurityLevel::UNINITIALIZED,
+            context()->AsWeakPtr(), nullptr));
+    provider_host_ = host->AsWeakPtr();
+    context()->RemoveProviderHost(host->process_id(), host->provider_id());
+    context()->AddProviderHost(std::move(host));
+
+    scoped_refptr<ServiceWorkerRegistration> registration =
+        new ServiceWorkerRegistration(GURL("https://host/scope"), 1L,
+                                      context()->AsWeakPtr());
+    scoped_refptr<ServiceWorkerVersion> version = new ServiceWorkerVersion(
+        registration.get(), GURL("https://host/script.js"), 1L,
+        context()->AsWeakPtr());
+
+    provider_host_->running_hosted_version_ = version;
+  }
 
   std::unique_ptr<net::URLRequest> CreateRequest(const GURL& request_url,
                                                  ResourceType resource_type) {
     std::unique_ptr<net::URLRequest> request = request_context_.CreateRequest(
         request_url, net::DEFAULT_PRIORITY, &request_delegate_);
     ResourceRequestInfo::AllocateForTesting(
         request.get(), resource_type, &resource_context_,
         -1 /* render_process_id */, -1 /* render_view_id */,
         -1 /* render_frame_id */, resource_type == RESOURCE_TYPE_MAIN_FRAME,
         false /* parent_is_main_frame */, true /* allow_download */,
         true /* is_async */, false /* is_using_lofi */);
     ResourceRequestInfoImpl::ForRequest(request.get())
         ->set_initiated_in_secure_context_for_testing(true);
 
     ServiceWorkerRequestHandler::InitializeHandler(
         request.get(), context_wrapper(), &blob_storage_context_,
-        helper_->mock_render_process_id(), kMockProviderId,
-        false /* skip_service_worker */, FETCH_REQUEST_MODE_NO_CORS,
-        FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE,
-        resource_type, REQUEST_CONTEXT_TYPE_HYPERLINK,
-        REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL, nullptr);
+        render_process_id(), kMockProviderId, false /* skip_service_worker */,
+        FETCH_REQUEST_MODE_NO_CORS, FETCH_CREDENTIALS_MODE_OMIT,
+        FetchRedirectMode::FOLLOW_MODE, resource_type,
+        REQUEST_CONTEXT_TYPE_HYPERLINK, REQUEST_CONTEXT_FRAME_TYPE_TOP_LEVEL,
+        nullptr);
 
     return request;
   }
 
   std::unique_ptr<net::URLRequest> CreateSubresourceRequest(
       const GURL& request_url) {
     return CreateRequest(request_url, RESOURCE_TYPE_SCRIPT);
   }
 
   std::vector<ServiceWorkerRegistrationInfo> GetRegistrations() {
@@ skipping 213 matching lines @@
       CreateRequest(GURL("https://example.com/foo/bar/"),
                     RESOURCE_TYPE_MAIN_FRAME)
           .get(),
       "<../foo.js>; rel=serviceworker", context_wrapper());
   base::RunLoop().RunUntilIdle();
 
   std::vector<ServiceWorkerRegistrationInfo> registrations = GetRegistrations();
   ASSERT_EQ(0u, registrations.size());
 }
 
+TEST_P(LinkHeaderServiceWorkerTestP,
+       InstallServiceWorker_FromWorkerWithoutControllees) {
+  CreateServiceWorkerProviderHost();
+  ProcessLinkHeaderForRequest(
+      CreateSubresourceRequest(GURL("https://example.com/foo/bar/")).get(),
+      "<../foo.js>; rel=serviceworker", context_wrapper());
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<ServiceWorkerRegistrationInfo> registrations = GetRegistrations();
+  ASSERT_EQ(0u, registrations.size());
+}
+
+TEST_P(LinkHeaderServiceWorkerTestP,
+       InstallServiceWorker_FromWorkerWithControllees) {
+  CreateServiceWorkerProviderHost();
+
+  std::unique_ptr<ServiceWorkerProviderHost> controllee(
+      new ServiceWorkerProviderHost(
+          render_process_id(), MSG_ROUTING_NONE, kMockProviderId,
+          SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+          ServiceWorkerProviderHost::FrameSecurityLevel::UNINITIALIZED,
+          context()->AsWeakPtr(), nullptr));
+  provider_host()->running_hosted_version()->AddControllee(controllee.get());
+
+  ProcessLinkHeaderForRequest(
+      CreateSubresourceRequest(GURL("https://example.com/foo/bar/")).get(),
+      "<../foo.js>; rel=serviceworker", context_wrapper());
+  base::RunLoop().RunUntilIdle();
+
+  std::vector<ServiceWorkerRegistrationInfo> registrations = GetRegistrations();
+  ASSERT_EQ(1u, registrations.size());
+}
+
 INSTANTIATE_TEST_CASE_P(LinkHeaderServiceWorkerTest,
                         LinkHeaderServiceWorkerTestP,
                         testing::Bool());
 
-}  // namespace
-
 }  // namespace content