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 58 matching lines @@
     const int64_t kVersionId = 0;
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
     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));
+    std::unique_ptr<ServiceWorkerProviderHost> host =
+        ServiceWorkerProviderHost::CreateForTesting(
+            helper_->mock_render_process_id(), kMockProviderId,
+            SERVICE_WORKER_PROVIDER_FOR_WINDOW,
+            helper_->context()->AsWeakPtr());
+    host->set_parent_frame_secure(true);
     host->SetDocumentUrl(GURL("https://host/scope/"));
     provider_host_ = host->AsWeakPtr();
     context()->AddProviderHost(std::move(host));
 
     context()->storage()->LazyInitialize(base::Bind(&EmptyCallback));
     base::RunLoop().RunUntilIdle();
 
     std::vector<ServiceWorkerDatabase::ResourceRecord> records;
     records.push_back(
         ServiceWorkerDatabase::ResourceRecord(10, version_->script_url(), 100));
@@ skipping 61 matching lines @@
         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 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 =
+        ServiceWorkerProviderHost::CreateForTesting(
+            helper_->mock_render_process_id(), kMockProviderId,
+            SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
+            helper_->context()->AsWeakPtr());
     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());
@@ skipping 178 matching lines @@
   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 */);
   ASSERT_TRUE(handler);
   EXPECT_EQ(remaining_time, timeout_for_request(handler));
 }
 
 }  // namespace content