service worker: Remove ServiceWorkerStorage::DidFindRegistration()

This CL moves ScheduleDeleteAndStartOver() call from
ServiceWorkerStorage::DidFindRegistration() to ServiceWorkerRegistry
so that we can reduce ServiceWorkerContextCore dependency from
ServiceWorkerStorage. DidFindRegistration() is removed as a
consequence of this change because it just called
ScheduleDeleteAndStartOver() and converted status.

Bug: 1039200
Change-Id: I0af1314ab774617cacb7847a026c117835f77754
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2032447Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737246}

content/browser/service_worker/service_worker_registry.cc

@@ -656,9 +656,17 @@ void ServiceWorkerRegistry::DidFindRegistrationForClientUrl(
     const GURL& client_url,
     int64_t trace_event_id,
     FindRegistrationCallback callback,
-    blink::ServiceWorkerStatusCode status,
     std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-    std::unique_ptr<ResourceList> resources) {
+    std::unique_ptr<ResourceList> resources,
+    ServiceWorkerDatabase::Status database_status) {
+  if (database_status != ServiceWorkerDatabase::STATUS_OK &&
+      database_status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
+    ScheduleDeleteAndStartOver();
+  }
+
+  blink::ServiceWorkerStatusCode status =
+      ServiceWorkerStorage::DatabaseStatusToStatusCode(database_status);
+
   if (status == blink::ServiceWorkerStatusCode::kErrorNotFound) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =
@@ -696,9 +704,17 @@ void ServiceWorkerRegistry::DidFindRegistrationForClientUrl(
 
 void ServiceWorkerRegistry::DidFindRegistrationForScope(
     FindRegistrationCallback callback,
-    blink::ServiceWorkerStatusCode status,
     std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-    std::unique_ptr<ResourceList> resources) {
+    std::unique_ptr<ResourceList> resources,
+    ServiceWorkerDatabase::Status database_status) {
+  if (database_status != ServiceWorkerDatabase::STATUS_OK &&
+      database_status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
+    ScheduleDeleteAndStartOver();
+  }
+
+  blink::ServiceWorkerStatusCode status =
+      ServiceWorkerStorage::DatabaseStatusToStatusCode(database_status);
+
   scoped_refptr<ServiceWorkerRegistration> registration;
   if (status == blink::ServiceWorkerStatusCode::kOk) {
     DCHECK(data);
@@ -712,9 +728,17 @@ void ServiceWorkerRegistry::DidFindRegistrationForScope(
 void ServiceWorkerRegistry::DidFindRegistrationForId(
     int64_t registration_id,
     FindRegistrationCallback callback,
-    blink::ServiceWorkerStatusCode status,
     std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-    std::unique_ptr<ResourceList> resources) {
+    std::unique_ptr<ResourceList> resources,
+    ServiceWorkerDatabase::Status database_status) {
+  if (database_status != ServiceWorkerDatabase::STATUS_OK &&
+      database_status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND) {
+    ScheduleDeleteAndStartOver();
+  }
+
+  blink::ServiceWorkerStatusCode status =
+      ServiceWorkerStorage::DatabaseStatusToStatusCode(database_status);
+
   if (status == blink::ServiceWorkerStatusCode::kErrorNotFound) {
     // Look for something currently being installed.
     scoped_refptr<ServiceWorkerRegistration> installing_registration =

content/browser/service_worker/service_worker_registry.h

@@ -223,20 +223,20 @@ class CONTENT_EXPORT ServiceWorkerRegistry {
       const GURL& client_url,
       int64_t trace_event_id,
       FindRegistrationCallback callback,
-      blink::ServiceWorkerStatusCode status,
       std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-      std::unique_ptr<ResourceList> resources);
+      std::unique_ptr<ResourceList> resources,
+      ServiceWorkerDatabase::Status database_status);
   void DidFindRegistrationForScope(
       FindRegistrationCallback callback,
-      blink::ServiceWorkerStatusCode status,
       std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-      std::unique_ptr<ResourceList> resources);
+      std::unique_ptr<ResourceList> resources,
+      ServiceWorkerDatabase::Status database_status);
   void DidFindRegistrationForId(
       int64_t registration_id,
       FindRegistrationCallback callback,
-      blink::ServiceWorkerStatusCode status,
       std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-      std::unique_ptr<ResourceList> resources);
+      std::unique_ptr<ResourceList> resources,
+      ServiceWorkerDatabase::Status database_status);
 
   void DidGetRegistrationsForOrigin(
       GetRegistrationsCallback callback,

content/browser/service_worker/service_worker_storage.cc

@@ -130,8 +130,9 @@ void ServiceWorkerStorage::FindRegistrationForClientUrl(
   DCHECK(!client_url.has_ref());
   switch (state_) {
     case STORAGE_STATE_DISABLED:
-      std::move(callback).Run(blink::ServiceWorkerStatusCode::kErrorAbort,
-                              /*data=*/nullptr, /*resources=*/nullptr);
+      std::move(callback).Run(
+          /*data=*/nullptr, /*resources=*/nullptr,
+          ServiceWorkerDatabase::STATUS_ERROR_DISABLED);
       return;
     case STORAGE_STATE_INITIALIZING:  // Fall-through.
     case STORAGE_STATE_UNINITIALIZED:
@@ -149,18 +150,16 @@ void ServiceWorkerStorage::FindRegistrationForClientUrl(
 
   // Bypass database lookup when there is no stored registration.
   if (!base::Contains(registered_origins_, client_url.GetOrigin())) {
-    std::move(callback).Run(blink::ServiceWorkerStatusCode::kErrorNotFound,
-                            /*data=*/nullptr, /*resources=*/nullptr);
+    std::move(callback).Run(
+        /*data=*/nullptr, /*resources=*/nullptr,
+        ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND);
     return;
   }
 
   database_task_runner_->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          &FindForClientUrlInDB, database_.get(),
-          base::ThreadTaskRunnerHandle::Get(), client_url,
-          base::BindOnce(&ServiceWorkerStorage::DidFindRegistration,
-                         weak_factory_.GetWeakPtr(), std::move(callback))));
+      FROM_HERE, base::BindOnce(&FindForClientUrlInDB, database_.get(),
+                                base::ThreadTaskRunnerHandle::Get(), client_url,
+                                std::move(callback)));
 }
 
 void ServiceWorkerStorage::FindRegistrationForScope(
@@ -170,8 +169,9 @@ void ServiceWorkerStorage::FindRegistrationForScope(
     case STORAGE_STATE_DISABLED:
       RunSoon(FROM_HERE,
               base::BindOnce(std::move(callback),
-                             blink::ServiceWorkerStatusCode::kErrorAbort,
-                             /*data=*/nullptr, /*resources=*/nullptr));
+
+                             /*data=*/nullptr, /*resources=*/nullptr,
+                             ServiceWorkerDatabase::STATUS_ERROR_DISABLED));
       return;
     case STORAGE_STATE_INITIALIZING:  // Fall-through.
     case STORAGE_STATE_UNINITIALIZED:
@@ -187,18 +187,15 @@ void ServiceWorkerStorage::FindRegistrationForScope(
   if (!base::Contains(registered_origins_, scope.GetOrigin())) {
     RunSoon(FROM_HERE,
             base::BindOnce(std::move(callback),
-                           blink::ServiceWorkerStatusCode::kErrorNotFound,
-                           /*data=*/nullptr, /*resources=*/nullptr));
+                           /*data=*/nullptr, /*resources=*/nullptr,
+                           ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND));
     return;
   }
 
   database_task_runner_->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          &FindForScopeInDB, database_.get(),
-          base::ThreadTaskRunnerHandle::Get(), scope,
-          base::BindOnce(&ServiceWorkerStorage::DidFindRegistration,
-                         weak_factory_.GetWeakPtr(), std::move(callback))));
+      FROM_HERE, base::BindOnce(&FindForScopeInDB, database_.get(),
+                                base::ThreadTaskRunnerHandle::Get(), scope,
+                                std::move(callback)));
 }
 
 void ServiceWorkerStorage::FindRegistrationForId(
@@ -224,18 +221,16 @@ void ServiceWorkerStorage::FindRegistrationForId(
 
   // Bypass database lookup when there is no stored registration.
   if (!base::Contains(registered_origins_, origin)) {
-    std::move(callback).Run(blink::ServiceWorkerStatusCode::kErrorNotFound,
-                            /*data=*/nullptr, /*resources=*/nullptr);
+    std::move(callback).Run(
+        /*data=*/nullptr, /*resources=*/nullptr,
+        ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND);
     return;
   }
 
   database_task_runner_->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          &FindForIdInDB, database_.get(), base::ThreadTaskRunnerHandle::Get(),
-          registration_id, origin,
-          base::BindOnce(&ServiceWorkerStorage::DidFindRegistration,
-                         weak_factory_.GetWeakPtr(), std::move(callback))));
+      FROM_HERE, base::BindOnce(&FindForIdInDB, database_.get(),
+                                base::ThreadTaskRunnerHandle::Get(),
+                                registration_id, origin, std::move(callback)));
 }
 
 void ServiceWorkerStorage::FindRegistrationForIdOnly(
@@ -258,12 +253,9 @@ void ServiceWorkerStorage::FindRegistrationForIdOnly(
   }
 
   database_task_runner_->PostTask(
-      FROM_HERE,
-      base::BindOnce(
-          &FindForIdOnlyInDB, database_.get(),
-          base::ThreadTaskRunnerHandle::Get(), registration_id,
-          base::BindOnce(&ServiceWorkerStorage::DidFindRegistration,
-                         weak_factory_.GetWeakPtr(), std::move(callback))));
+      FROM_HERE, base::BindOnce(&FindForIdOnlyInDB, database_.get(),
+                                base::ThreadTaskRunnerHandle::Get(),
+                                registration_id, std::move(callback)));
 }
 
 void ServiceWorkerStorage::GetRegistrationsForOrigin(
@@ -1009,25 +1001,6 @@ void ServiceWorkerStorage::DidReadInitialData(
   pending_tasks_.clear();
 }
 
-void ServiceWorkerStorage::DidFindRegistration(
-    FindRegistrationDataCallback callback,
-    std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-    std::unique_ptr<ResourceList> resources,
-    ServiceWorkerDatabase::Status status) {
-  if (status == ServiceWorkerDatabase::STATUS_OK) {
-    DCHECK(!resources->empty());
-    std::move(callback).Run(blink::ServiceWorkerStatusCode::kOk,
-                            std::move(data), std::move(resources));
-    return;
-  }
-
-  if (status != ServiceWorkerDatabase::STATUS_ERROR_NOT_FOUND)
-    ScheduleDeleteAndStartOver();
-
-  std::move(callback).Run(DatabaseStatusToStatusCode(status), /*data=*/nullptr,
-                          /*resources=*/nullptr);
-}
-
 void ServiceWorkerStorage::DidGetRegistrationsForOrigin(
     GetRegistrationsDataCallback callback,
     std::unique_ptr<RegistrationList> registration_data_list,

content/browser/service_worker/service_worker_storage.h

@@ -71,9 +71,9 @@ class CONTENT_EXPORT ServiceWorkerStorage {
   using StatusCallback =
       base::OnceCallback<void(blink::ServiceWorkerStatusCode status)>;
   using FindRegistrationDataCallback = base::OnceCallback<void(
-      blink::ServiceWorkerStatusCode status,
       std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-      std::unique_ptr<ResourceList> resources)>;
+      std::unique_ptr<ResourceList> resources,
+      ServiceWorkerDatabase::Status status)>;
   using GetRegistrationsDataCallback = base::OnceCallback<void(
       blink::ServiceWorkerStatusCode status,
       std::unique_ptr<RegistrationList> registrations,
@@ -365,11 +365,6 @@ class CONTENT_EXPORT ServiceWorkerStorage {
   void LazyInitialize(base::OnceClosure callback);
   void DidReadInitialData(std::unique_ptr<InitialData> data,
                           ServiceWorkerDatabase::Status status);
-  void DidFindRegistration(
-      FindRegistrationDataCallback callback,
-      std::unique_ptr<ServiceWorkerDatabase::RegistrationData> data,
-      std::unique_ptr<ResourceList> resources,
-      ServiceWorkerDatabase::Status status);
   void DidGetRegistrationsForOrigin(
       GetRegistrationsDataCallback callback,
       std::unique_ptr<RegistrationList> registrations,