Manage ServiceWorkerDispatcherHost in ServiceWorkerContextCore

content/browser/service_worker/foreign_fetch_request_handler_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/foreign_fetch_request_handler.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "content/browser/browser_thread_impl.h"
@@ skipping 50 matching lines @@
     SetBrowserClientForTesting(&test_content_browser_client_);
   }
   ~ForeignFetchRequestHandlerTest() override {}
 
   void SetUp() override {
     const GURL kScope("https://valid.example.com/scope/");
     const GURL kResource1("https://valid.example.com/scope/sw.js");
     const int64_t kRegistrationId = 0;
     const int64_t kVersionId = 0;
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
+
+    // Create a registration for the worker which has foreign fetch event
+    // handler.
     registration_ = new ServiceWorkerRegistration(kScope, kRegistrationId,
                                                   context()->AsWeakPtr());
     version_ = new ServiceWorkerVersion(registration_.get(), kResource1,
                                         kVersionId, context()->AsWeakPtr());
-
     version_->set_foreign_fetch_scopes({kScope});
 
-    // An empty host.
-    std::unique_ptr<ServiceWorkerProviderHost> host(
-        new ServiceWorkerProviderHost(
-            helper_->mock_render_process_id(), MSG_ROUTING_NONE,
-            kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_WINDOW,
-            ServiceWorkerProviderHost::FrameSecurityLevel::SECURE,
-            context()->AsWeakPtr(), nullptr));
-    host->SetDocumentUrl(GURL("https://host/scope/"));
-    provider_host_ = host->AsWeakPtr();
-    context()->AddProviderHost(std::move(host));

[falken, 2017/02/08 06:53:51]

I may be missing something but it looks like you can still call
CreateWindowTypeProviderHost here and then you don't need to call it in each
test.

[shimazu, 2017/02/13 03:25:56]

Yes I can, but I thought that makes this test a bit complicated like
context()->RemoveProviderHost() should be called before AddProviderHost in
CreateServiceWorkerTypeProviderHost() if CreateWindowTypeProviderHost() calls
here. 
It's easier to understand if CreateWindowTypeProviderHost and
CreateServiceWorkerTypeProviderHost are symmetrical and do mostly the same thing
instead of calling CreateWindowTypeProviderHost by default.

What do you think? 

-
     context()->storage()->LazyInitialize(base::Bind(&EmptyCallback));
     base::RunLoop().RunUntilIdle();
 
+    // Persist the registration data.
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
     version_->script_cache_map()->SetResources(records);
     version_->set_fetch_handler_existence(
         ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
     version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
     registration_->SetActiveVersion(version_);
     context()->storage()->StoreRegistration(
         registration_.get(), version_.get(),
@@ skipping 53 matching lines @@
         helper_->mock_render_process_id(), kMockProviderId,
         SkipServiceWorker::NONE, FETCH_REQUEST_MODE_CORS,
         FETCH_CREDENTIALS_MODE_OMIT, FetchRedirectMode::FOLLOW_MODE,
         resource_type, REQUEST_CONTEXT_TYPE_FETCH,
         REQUEST_CONTEXT_FRAME_TYPE_NONE, nullptr,
         true /* initiated_in_secure_context */);
 
     return ForeignFetchRequestHandler::GetHandler(request_.get());
   }
 
+  void CreateWindowTypeProviderHost() {
+    std::unique_ptr<ServiceWorkerProviderHost> host =
+        CreateProviderHostForWindow(
+            helper_->mock_render_process_id(), kMockProviderId,
+            true /* is_parent_frame_secure */, helper_->context()->AsWeakPtr());
+    EXPECT_FALSE(
+        context()->GetProviderHost(host->process_id(), host->provider_id()));
+    host->SetDocumentUrl(GURL("https://host/scope/"));
+    provider_host_ = host->AsWeakPtr();
+    context()->AddProviderHost(std::move(host));
+  }
+
   void CreateServiceWorkerTypeProviderHost() {
-    std::unique_ptr<ServiceWorkerProviderHost> host(
-        new ServiceWorkerProviderHost(
-            helper_->mock_render_process_id(), MSG_ROUTING_NONE,
-            kMockProviderId, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
-            ServiceWorkerProviderHost::FrameSecurityLevel::UNINITIALIZED,
-            context()->AsWeakPtr(), nullptr));
+    std::unique_ptr<ServiceWorkerProviderHost> host =
+        CreateProviderHostForServiceWorkerContext(
+            helper_->mock_render_process_id(), kMockProviderId,
+            true /* is_parent_frame_secure */, helper_->context()->AsWeakPtr());
+    EXPECT_FALSE(
+        context()->GetProviderHost(host->process_id(), host->provider_id()));
     provider_host_ = host->AsWeakPtr();
-    context()->RemoveProviderHost(host->process_id(), host->provider_id());
     context()->AddProviderHost(std::move(host));
 
+    // Create another worker whose requests will be intercepted by the foreign
+    // fetch event handler.
     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());
 
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version->script_url(), 100));
@@ skipping 43 matching lines @@
   net::URLRequestContext url_request_context_;
   MockURLRequestDelegate url_request_delegate_;
   base::WeakPtr<ServiceWorkerProviderHost> provider_host_;
   storage::BlobStorageContext blob_storage_context_;
   std::unique_ptr<net::URLRequest> request_;
 
   DISALLOW_COPY_AND_ASSIGN(ForeignFetchRequestHandlerTest);
 };
 
 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_NoToken) {
+  CreateWindowTypeProviderHost();
   EXPECT_TRUE(CheckOriginTrialToken(version()));
   std::unique_ptr<net::HttpResponseInfo> http_info(
       CreateTestHttpResponseInfo());
   version()->SetMainScriptHttpResponseInfo(*http_info);
   EXPECT_FALSE(CheckOriginTrialToken(version()));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_ValidToken) {
+  CreateWindowTypeProviderHost();
   EXPECT_TRUE(CheckOriginTrialToken(version()));
   std::unique_ptr<net::HttpResponseInfo> http_info(
       CreateTestHttpResponseInfo());
   const std::string kOriginTrial("Origin-Trial: ");
   // Token for ForeignFetch which expires 2033-05-18.
   // generate_token.py valid.example.com ForeignFetch
   // --expire-timestamp=2000000000
   // TODO(horo): Generate this sample token during the build.
   const std::string kFeatureToken(
       "AsDmvl17hoVfq9G6OT0VEhX28Nnl0VnbGZJoG6XFzosIamNfxNJ28m40PRA3PtFv3BfOlRe1"
       "5bLrEZhtICdDnwwAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0"
       "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0"
       "=");
   http_info->headers->AddHeader(kOriginTrial + kFeatureToken);
   version()->SetMainScriptHttpResponseInfo(*http_info);
   EXPECT_TRUE(CheckOriginTrialToken(version()));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_InvalidToken) {
+  CreateWindowTypeProviderHost();
   EXPECT_TRUE(CheckOriginTrialToken(version()));
   std::unique_ptr<net::HttpResponseInfo> http_info(
       CreateTestHttpResponseInfo());
   const std::string kOriginTrial("Origin-Trial: ");
   // Token for FooBar which expires 2033-05-18.
   // generate_token.py valid.example.com FooBar
   // --expire-timestamp=2000000000
   // TODO(horo): Generate this sample token during the build.
   const std::string kFeatureToken(
       "AqwtRpuoLdc6MKSFH8TbzoLFvLouL8VXTv6OJIqQvRtJBynRMbAbFwjUlcwMuj4pXUBbquBj"
       "zj/w/d1H/ZsOcQIAAABWeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0"
       "NDMiLCAiZmVhdHVyZSI6ICJGb29CYXIiLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0=");
   http_info->headers->AddHeader(kOriginTrial + kFeatureToken);
   version()->SetMainScriptHttpResponseInfo(*http_info);
   EXPECT_FALSE(CheckOriginTrialToken(version()));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, CheckOriginTrialToken_ExpiredToken) {
+  CreateWindowTypeProviderHost();
   EXPECT_TRUE(CheckOriginTrialToken(version()));
   std::unique_ptr<net::HttpResponseInfo> http_info(
       CreateTestHttpResponseInfo());
   const std::string kOriginTrial("Origin-Trial: ");
   // Token for ForeignFetch which expired 2001-09-09.
   // generate_token.py valid.example.com ForeignFetch
   // --expire-timestamp=1000000000
   const std::string kFeatureToken(
       "AgBgj4Zhwzn85LJw7rzh4ZFRFqp49+9Es2SrCwZdDcoqtqQEjbvui4SKLn6GqMpr4DynGfJh"
       "tIy9dpOuK8PVTwkAAABceyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5leGFtcGxlLmNvbTo0"
       "NDMiLCAiZmVhdHVyZSI6ICJGb3JlaWduRmV0Y2giLCAiZXhwaXJ5IjogMTAwMDAwMDAwMH0"
       "=");
   http_info->headers->AddHeader(kOriginTrial + kFeatureToken);
   version()->SetMainScriptHttpResponseInfo(*http_info);
   EXPECT_FALSE(CheckOriginTrialToken(version()));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_Success) {
+  CreateWindowTypeProviderHost();
   EXPECT_TRUE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE,
                                 nullptr /* initiator */));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_WrongResourceType) {
+  CreateWindowTypeProviderHost();
   EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_MAIN_FRAME,
                                  nullptr /* initiator */));
   EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SUB_FRAME,
                                  nullptr /* initiator */));
   EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_WORKER,
                                  nullptr /* initiator */));
   EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SHARED_WORKER,
                                  nullptr /* initiator */));
   EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_SERVICE_WORKER,
                                  nullptr /* initiator */));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_SameOriginRequest) {
+  CreateWindowTypeProviderHost();
   EXPECT_FALSE(InitializeHandler(kValidUrl, RESOURCE_TYPE_IMAGE,
                                  kValidUrl /* initiator */));
 }
 
 TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_NoRegisteredHandlers) {
+  CreateWindowTypeProviderHost();
   EXPECT_FALSE(InitializeHandler("https://invalid.example.com/foo",
                                  RESOURCE_TYPE_IMAGE, nullptr /* initiator */));
 }
 
-TEST_F(ForeignFetchRequestHandlerTest, InitializeHandler_TimeoutBehavior) {
+TEST_F(ForeignFetchRequestHandlerTest,
+       InitializeHandler_TimeoutBehaviorForWindow) {
+  CreateWindowTypeProviderHost();
   ForeignFetchRequestHandler* handler =
       InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE,
                         nullptr /* initiator */);
   ASSERT_TRUE(handler);
 
   EXPECT_EQ(base::nullopt, timeout_for_request(handler));
+}
 
+TEST_F(ForeignFetchRequestHandlerTest,
+       InitializeHandler_TimeoutBehaviorForServiceWorker) {
   CreateServiceWorkerTypeProviderHost();
   ServiceWorkerVersion* version = provider_host()->running_hosted_version();
   std::unique_ptr<net::HttpResponseInfo> http_info(
       CreateTestHttpResponseInfo());
   version->SetMainScriptHttpResponseInfo(*http_info);
 
   // Set mock clock on version to check timeout behavior.
   base::SimpleTestTickClock* tick_clock = new base::SimpleTestTickClock();
   tick_clock->SetNowTicks(base::TimeTicks::Now());
   version->SetTickClockForTesting(base::WrapUnique(tick_clock));
 
   // Make sure worker has a non-zero timeout.
   version->StartWorker(ServiceWorkerMetrics::EventType::UNKNOWN,
                        base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   base::RunLoop().RunUntilIdle();
   version->StartRequestWithCustomTimeout(
       ServiceWorkerMetrics::EventType::ACTIVATE,
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback),
       base::TimeDelta::FromSeconds(10), ServiceWorkerVersion::KILL_ON_TIMEOUT);
 
   // Advance clock by a couple seconds.
   tick_clock->Advance(base::TimeDelta::FromSeconds(4));
   base::TimeDelta remaining_time = version->remaining_timeout();
   EXPECT_EQ(base::TimeDelta::FromSeconds(6), remaining_time);
 
   // Make sure new request only gets remaining timeout.
-  handler = InitializeHandler("https://valid.example.com/foo",
-                              RESOURCE_TYPE_IMAGE, nullptr /* initiator */);
+  ForeignFetchRequestHandler* handler =
+      InitializeHandler("https://valid.example.com/foo", RESOURCE_TYPE_IMAGE,
+                        nullptr /* initiator */);
   ASSERT_TRUE(handler);
-  EXPECT_EQ(remaining_time, timeout_for_request(handler));
+  ASSERT_TRUE(timeout_for_request(handler).has_value());
+  EXPECT_EQ(remaining_time, timeout_for_request(handler).value());
 }
 
 }  // namespace content