Manage ServiceWorkerDispatcherHost in ServiceWorkerContextCore

content/browser/service_worker/service_worker_context_core.cc

 // Copyright 2013 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/service_worker_context_core.h"
 
 #include <limits>
 #include <set>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_database_task_manager.h"
+#include "content/browser/service_worker/service_worker_dispatcher_host.h"
 #include "content/browser/service_worker/service_worker_info.h"
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_register_job.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "ipc/ipc_message.h"
@@ skipping 176 matching lines @@
 
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     const base::FilePath& path,
     std::unique_ptr<ServiceWorkerDatabaseTaskManager> database_task_manager,
     const scoped_refptr<base::SingleThreadTaskRunner>& disk_cache_thread,
     storage::QuotaManagerProxy* quota_manager_proxy,
     storage::SpecialStoragePolicy* special_storage_policy,
     base::ObserverListThreadSafe<ServiceWorkerContextObserver>* observer_list,
     ServiceWorkerContextWrapper* wrapper)
     : wrapper_(wrapper),
-      providers_(new ProcessToProviderMap),
-      provider_by_uuid_(new ProviderByClientUUIDMap),
+      providers_(base::MakeUnique<ProcessToProviderMap>()),
+      provider_by_uuid_(base::MakeUnique<ProviderByClientUUIDMap>()),
       force_update_on_page_load_(false),
       next_handle_id_(0),
       next_registration_handle_id_(0),
       was_service_worker_registered_(false),
       observer_list_(observer_list),
       weak_factory_(this) {
   // These get a WeakPtr from weak_factory_, so must be set after weak_factory_
   // is initialized.
   storage_ = ServiceWorkerStorage::Create(
       path, AsWeakPtr(), std::move(database_task_manager), disk_cache_thread,
       quota_manager_proxy, special_storage_policy);
   embedded_worker_registry_ = EmbeddedWorkerRegistry::Create(AsWeakPtr());
   job_coordinator_.reset(new ServiceWorkerJobCoordinator(AsWeakPtr()));
 }
 
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     ServiceWorkerContextCore* old_context,
     ServiceWorkerContextWrapper* wrapper)
     : wrapper_(wrapper),
+      dispatcher_hosts_(std::move(old_context->dispatcher_hosts_)),
       providers_(old_context->providers_.release()),
       provider_by_uuid_(old_context->provider_by_uuid_.release()),
       next_handle_id_(old_context->next_handle_id_),
       next_registration_handle_id_(old_context->next_registration_handle_id_),
       was_service_worker_registered_(
           old_context->was_service_worker_registered_),
       observer_list_(old_context->observer_list_),
       weak_factory_(this) {
   // These get a WeakPtr from weak_factory_, so must be set after weak_factory_
   // is initialized.
   storage_ = ServiceWorkerStorage::Create(AsWeakPtr(), old_context->storage());
   embedded_worker_registry_ = EmbeddedWorkerRegistry::Create(
       AsWeakPtr(),
       old_context->embedded_worker_registry());
   job_coordinator_.reset(new ServiceWorkerJobCoordinator(AsWeakPtr()));
 }
 
 ServiceWorkerContextCore::~ServiceWorkerContextCore() {
   DCHECK(storage_);
   for (VersionMap::iterator it = live_versions_.begin();
        it != live_versions_.end();
        ++it) {
     it->second->RemoveListener(this);
   }
   weak_factory_.InvalidateWeakPtrs();
 }
 
-ServiceWorkerProviderHost* ServiceWorkerContextCore::GetProviderHost(
-    int process_id, int provider_id) {
-  ProviderMap* map = GetProviderMapForProcess(process_id);
-  if (!map)
-    return NULL;
-  return map->Lookup(provider_id);
+void ServiceWorkerContextCore::AddDispatcherHost(
+    int process_id,
+    content::ServiceWorkerDispatcherHost* dispatcher_host) {
+  DCHECK(dispatcher_hosts_.find(process_id) == dispatcher_hosts_.end());
+  dispatcher_hosts_[process_id] = dispatcher_host;
+}
+
+ServiceWorkerDispatcherHost* ServiceWorkerContextCore::GetDispatcherHost(
+    int process_id) {
+  auto it = dispatcher_hosts_.find(process_id);
+  if (it == dispatcher_hosts_.end())
+    return nullptr;
+  return it->second;
+}
+
+void ServiceWorkerContextCore::RemoveDispatcherHost(int process_id) {
+  DCHECK(dispatcher_hosts_.find(process_id) != dispatcher_hosts_.end());
+  RemoveAllProviderHostsForProcess(process_id);
+  embedded_worker_registry_->RemoveProcess(process_id);
+  dispatcher_hosts_.erase(process_id);
 }
 
 void ServiceWorkerContextCore::AddProviderHost(
     std::unique_ptr<ServiceWorkerProviderHost> host) {
   int process_id = host->process_id();
   int provider_id = host->provider_id();
   ProviderMap* map = GetProviderMapForProcess(process_id);
   if (!map) {
     providers_->AddWithID(base::MakeUnique<ProviderMap>(), process_id);
     map = GetProviderMapForProcess(process_id);
   }
   map->AddWithID(std::move(host), provider_id);
 }
 
+ServiceWorkerProviderHost* ServiceWorkerContextCore::GetProviderHost(
+    int process_id,
+    int provider_id) {
+  ProviderMap* map = GetProviderMapForProcess(process_id);
+  if (!map)
+    return nullptr;
+  return map->Lookup(provider_id);
+}
+
 void ServiceWorkerContextCore::RemoveProviderHost(
     int process_id, int provider_id) {
   ProviderMap* map = GetProviderMapForProcess(process_id);
   DCHECK(map);
   map->Remove(provider_id);
 }
 
 void ServiceWorkerContextCore::RemoveAllProviderHostsForProcess(
     int process_id) {
   if (providers_->Lookup(process_id))
@@ skipping 197 matching lines @@
   if (status == SERVICE_WORKER_OK && observer_list_.get()) {
     observer_list_->Notify(FROM_HERE,
                            &ServiceWorkerContextObserver::OnRegistrationDeleted,
                            registration_id, pattern);
   }
 }
 
 ServiceWorkerRegistration* ServiceWorkerContextCore::GetLiveRegistration(
     int64_t id) {
   RegistrationsMap::iterator it = live_registrations_.find(id);
-  return (it != live_registrations_.end()) ? it->second : NULL;
+  return (it != live_registrations_.end()) ? it->second : nullptr;
 }
 
 void ServiceWorkerContextCore::AddLiveRegistration(
     ServiceWorkerRegistration* registration) {
   // TODO(nhiroki): Change CHECK to DCHECK after https://crbug.com/619294 is
   // fixed.
   CHECK(!GetLiveRegistration(registration->id()));
   live_registrations_[registration->id()] = registration;
   if (observer_list_.get()) {
     observer_list_->Notify(FROM_HERE,
                            &ServiceWorkerContextObserver::OnNewLiveRegistration,
                            registration->id(), registration->pattern());
   }
 }
 
 void ServiceWorkerContextCore::RemoveLiveRegistration(int64_t id) {
   live_registrations_.erase(id);
 }
 
 ServiceWorkerVersion* ServiceWorkerContextCore::GetLiveVersion(int64_t id) {
   VersionMap::iterator it = live_versions_.find(id);
-  return (it != live_versions_.end()) ? it->second : NULL;
+  return (it != live_versions_.end()) ? it->second : nullptr;
 }
 
 // PlzNavigate
 void ServiceWorkerContextCore::AddNavigationHandleCore(
     int service_worker_provider_id,
     ServiceWorkerNavigationHandleCore* handle) {
   auto result = navigation_handle_cores_map_.insert(
       std::pair<int, ServiceWorkerNavigationHandleCore*>(
           service_worker_provider_id, handle));
   DCHECK(result.second)
@@ skipping 88 matching lines @@
   job_coordinator_->AbortAll();
   storage_->DeleteAndStartOver(callback);
 }
 
 std::unique_ptr<ServiceWorkerProviderHost>
 ServiceWorkerContextCore::TransferProviderHostOut(int process_id,
                                                   int provider_id) {
   ProviderMap* map = GetProviderMapForProcess(process_id);
   ServiceWorkerProviderHost* transferee = map->Lookup(provider_id);
   std::unique_ptr<ServiceWorkerProviderHost> replacement =
-      base::MakeUnique<ServiceWorkerProviderHost>(
-          process_id, transferee->frame_id(), provider_id,
-          transferee->provider_type(),
-          transferee->is_parent_frame_secure()
-              ? ServiceWorkerProviderHost::FrameSecurityLevel::SECURE
-              : ServiceWorkerProviderHost::FrameSecurityLevel::INSECURE,
-          AsWeakPtr(), transferee->dispatcher_host());
-  transferee->PrepareForCrossSiteTransfer();
+      transferee->PrepareForCrossSiteTransfer();
   return map->Replace(provider_id, std::move(replacement));
 }
 
 void ServiceWorkerContextCore::TransferProviderHostIn(
     int new_process_id,
     int new_provider_id,
     std::unique_ptr<ServiceWorkerProviderHost> transferee) {
   ProviderMap* map = GetProviderMapForProcess(new_process_id);
   ServiceWorkerProviderHost* temp = map->Lookup(new_provider_id);
   if (!temp)
@@ skipping 207 matching lines @@
 }
 
 void ServiceWorkerContextCore::OnRegistrationFinishedForCheckHasServiceWorker(
     const ServiceWorkerContext::CheckHasServiceWorkerCallback callback,
     scoped_refptr<ServiceWorkerRegistration> registration) {
   callback.Run(registration->active_version() ||
                registration->waiting_version());
 }
 
 }  // namespace content