Rename ServiceWorkerContextObserver to ServiceWorkerContextCoreObserver.

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_core_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"
@@ skipping 197 matching lines @@
   }
   return false;
 }
 
 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,
+    base::ObserverListThreadSafe<ServiceWorkerContextCoreObserver>*
+        observer_list,
     ServiceWorkerContextWrapper* wrapper)
     : wrapper_(wrapper),
       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) {
@@ skipping 254 matching lines @@
     callback.Run(status, status_message, kInvalidServiceWorkerRegistrationId);
     return;
   }
 
   DCHECK(registration);
   callback.Run(status, status_message, registration->id());
   // TODO(falken): At this point the registration promise is resolved, but we
   // haven't persisted anything to storage yet. So we should either call
   // OnRegistrationStored somewhere else or change its name.
   if (observer_list_.get()) {
-    observer_list_->Notify(FROM_HERE,
-                           &ServiceWorkerContextObserver::OnRegistrationStored,
-                           registration->id(), pattern);
+    observer_list_->Notify(
+        FROM_HERE, &ServiceWorkerContextCoreObserver::OnRegistrationStored,
+        registration->id(), pattern);
   }
 }
 
 void ServiceWorkerContextCore::UpdateComplete(
     const ServiceWorkerContextCore::UpdateCallback& callback,
     ServiceWorkerStatusCode status,
     const std::string& status_message,
     ServiceWorkerRegistration* registration) {
   if (status != SERVICE_WORKER_OK) {
     DCHECK(!registration);
     callback.Run(status, status_message, kInvalidServiceWorkerRegistrationId);
     return;
   }
 
   DCHECK(registration);
   callback.Run(status, status_message, registration->id());
 }
 
 void ServiceWorkerContextCore::UnregistrationComplete(
     const GURL& pattern,
     const ServiceWorkerContextCore::UnregistrationCallback& callback,
     int64_t registration_id,
     ServiceWorkerStatusCode status) {
   callback.Run(status);
   if (status == SERVICE_WORKER_OK && observer_list_.get()) {
-    observer_list_->Notify(FROM_HERE,
-                           &ServiceWorkerContextObserver::OnRegistrationDeleted,
-                           registration_id, pattern);
+    observer_list_->Notify(
+        FROM_HERE, &ServiceWorkerContextCoreObserver::OnRegistrationDeleted,
+        registration_id, pattern);
   }
 }
 
 ServiceWorkerRegistration* ServiceWorkerContextCore::GetLiveRegistration(
     int64_t id) {
   RegistrationsMap::iterator it = live_registrations_.find(id);
   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());
+    observer_list_->Notify(
+        FROM_HERE, &ServiceWorkerContextCoreObserver::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 : nullptr;
@@ skipping 28 matching lines @@
 
 void ServiceWorkerContextCore::AddLiveVersion(ServiceWorkerVersion* version) {
   // TODO(horo): If we will see crashes here, we have to find the root cause of
   // the version ID conflict. Otherwise change CHECK to DCHECK.
   CHECK(!GetLiveVersion(version->version_id()));
   live_versions_[version->version_id()] = version;
   version->AddListener(this);
   if (observer_list_.get()) {
     ServiceWorkerVersionInfo version_info = version->GetInfo();
     observer_list_->Notify(FROM_HERE,
-                           &ServiceWorkerContextObserver::OnNewLiveVersion,
+                           &ServiceWorkerContextCoreObserver::OnNewLiveVersion,
                            version_info);
   }
 }
 
 void ServiceWorkerContextCore::RemoveLiveVersion(int64_t id) {
   live_versions_.erase(id);
 }
 
 std::vector<ServiceWorkerRegistrationInfo>
 ServiceWorkerContextCore::GetAllLiveRegistrationInfo() {
@@ skipping 136 matching lines @@
   auto it = failure_counts_.find(version_id);
   if (it == failure_counts_.end())
     return 0;
   return it->second.count;
 }
 
 void ServiceWorkerContextCore::OnRunningStateChanged(
     ServiceWorkerVersion* version) {
   if (!observer_list_)
     return;
-  observer_list_->Notify(FROM_HERE,
-                         &ServiceWorkerContextObserver::OnRunningStateChanged,
-                         version->version_id(), version->running_status());
+  observer_list_->Notify(
+      FROM_HERE, &ServiceWorkerContextCoreObserver::OnRunningStateChanged,
+      version->version_id(), version->running_status());
 }
 
 void ServiceWorkerContextCore::OnVersionStateChanged(
     ServiceWorkerVersion* version) {
   if (!observer_list_)
     return;
-  observer_list_->Notify(FROM_HERE,
-                         &ServiceWorkerContextObserver::OnVersionStateChanged,
-                         version->version_id(), version->status());
+  observer_list_->Notify(
+      FROM_HERE, &ServiceWorkerContextCoreObserver::OnVersionStateChanged,
+      version->version_id(), version->status());
 }
 
 void ServiceWorkerContextCore::OnDevToolsRoutingIdChanged(
     ServiceWorkerVersion* version) {
   if (!observer_list_ || !version->embedded_worker())
     return;
   observer_list_->Notify(
       FROM_HERE,
-      &ServiceWorkerContextObserver::OnVersionDevToolsRoutingIdChanged,
+      &ServiceWorkerContextCoreObserver::OnVersionDevToolsRoutingIdChanged,
       version->version_id(), version->embedded_worker()->process_id(),
       version->embedded_worker()->worker_devtools_agent_route_id());
 }
 
 void ServiceWorkerContextCore::OnMainScriptHttpResponseInfoSet(
     ServiceWorkerVersion* version) {
   if (!observer_list_)
     return;
   const net::HttpResponseInfo* info = version->GetMainScriptHttpResponseInfo();
   DCHECK(info);
   base::Time lastModified;
   if (info->headers)
     info->headers->GetLastModifiedValue(&lastModified);
   observer_list_->Notify(
-      FROM_HERE, &ServiceWorkerContextObserver::OnMainScriptHttpResponseInfoSet,
+      FROM_HERE,
+      &ServiceWorkerContextCoreObserver::OnMainScriptHttpResponseInfoSet,
       version->version_id(), info->response_time, lastModified);
 }
 
 void ServiceWorkerContextCore::OnErrorReported(
     ServiceWorkerVersion* version,
     const base::string16& error_message,
     int line_number,
     int column_number,
     const GURL& source_url) {
   if (!observer_list_)
     return;
   observer_list_->Notify(
-      FROM_HERE, &ServiceWorkerContextObserver::OnErrorReported,
+      FROM_HERE, &ServiceWorkerContextCoreObserver::OnErrorReported,
       version->version_id(), version->embedded_worker()->process_id(),
       version->embedded_worker()->thread_id(),
-      ServiceWorkerContextObserver::ErrorInfo(error_message, line_number,
-                                              column_number, source_url));
+      ServiceWorkerContextCoreObserver::ErrorInfo(error_message, line_number,
+                                                  column_number, source_url));
 }
 
 void ServiceWorkerContextCore::OnReportConsoleMessage(
     ServiceWorkerVersion* version,
     int source_identifier,
     int message_level,
     const base::string16& message,
     int line_number,
     const GURL& source_url) {
   if (!observer_list_)
     return;
   observer_list_->Notify(
-      FROM_HERE, &ServiceWorkerContextObserver::OnReportConsoleMessage,
+      FROM_HERE, &ServiceWorkerContextCoreObserver::OnReportConsoleMessage,
       version->version_id(), version->embedded_worker()->process_id(),
       version->embedded_worker()->thread_id(),
-      ServiceWorkerContextObserver::ConsoleMessage(
+      ServiceWorkerContextCoreObserver::ConsoleMessage(
           source_identifier, message_level, message, line_number, source_url));
 }
 
 void ServiceWorkerContextCore::OnControlleeAdded(
     ServiceWorkerVersion* version,
     ServiceWorkerProviderHost* provider_host) {
   if (!observer_list_)
     return;
   observer_list_->Notify(
-      FROM_HERE, &ServiceWorkerContextObserver::OnControlleeAdded,
+      FROM_HERE, &ServiceWorkerContextCoreObserver::OnControlleeAdded,
       version->version_id(), provider_host->client_uuid(),
       provider_host->process_id(), provider_host->route_id(),
       provider_host->web_contents_getter(), provider_host->provider_type());
 }
 
 void ServiceWorkerContextCore::OnControlleeRemoved(
     ServiceWorkerVersion* version,
     ServiceWorkerProviderHost* provider_host) {
   if (!observer_list_)
     return;
   observer_list_->Notify(FROM_HERE,
-                         &ServiceWorkerContextObserver::OnControlleeRemoved,
+                         &ServiceWorkerContextCoreObserver::OnControlleeRemoved,
                          version->version_id(), provider_host->client_uuid());
 }
 
 ServiceWorkerProcessManager* ServiceWorkerContextCore::process_manager() {
   return wrapper_->process_manager();
 }
 
 void ServiceWorkerContextCore::DidFindRegistrationForCheckHasServiceWorker(
     const GURL& other_url,
     const ServiceWorkerContext::CheckHasServiceWorkerCallback callback,
@@ skipping 41 matching lines @@
     int service_worker_provider_id,
     mojom::ServiceWorkerWorkerClientAssociatedPtrInfo client_ptr_info) {
   ServiceWorkerProviderHost* provider_host =
       GetProviderHost(render_process_id, service_worker_provider_id);
   if (!provider_host)
     return;
   provider_host->BindWorkerFetchContext(std::move(client_ptr_info));
 }
 
 }  // namespace content