ServiceWorker: Stop exposing ServiceWorkerContextCore

content/browser/service_worker/service_worker_internals_ui.cc

 // Copyright 2014 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_internals_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 60 matching lines @@
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(CallServiceWorkerVersionMethodWithVersionID,
                    method,
                    context,
                    version_id,
                    callback));
     return;
   }
 
-  if (!context->context()) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT);
-    return;
-  }
-
   scoped_refptr<ServiceWorkerVersion> version =
-      context->context()->GetLiveVersion(version_id);
+      context->GetLiveVersion(version_id);
   if (!version.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   (*version.get().*method)(callback);
 }
 
 void DispatchPushEventWithVersionID(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     int64 version_id,
     const ServiceWorkerInternalsUI::StatusCallback& callback) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(DispatchPushEventWithVersionID,
                    context,
                    version_id,
                    callback));
     return;
   }
 
-  if (!context->context()) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT);
-    return;
-  }
-
   scoped_refptr<ServiceWorkerVersion> version =
-      context->context()->GetLiveVersion(version_id);
+      context->GetLiveVersion(version_id);
   if (!version.get()) {
     callback.Run(SERVICE_WORKER_ERROR_NOT_FOUND);
     return;
   }
   std::string data = "Test push message from ServiceWorkerInternals.";
   version->DispatchPushEvent(callback, data);
 }
 
-void UnregisterWithScope(
-    scoped_refptr<ServiceWorkerContextWrapper> context,
-    const GURL& scope,
-    const ServiceWorkerInternalsUI::StatusCallback& callback) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(UnregisterWithScope, context, scope, callback));
-    return;
-  }
-
-  if (!context->context()) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT);
-    return;
-  }
-  context->context()->UnregisterServiceWorker(scope, callback);
-}
-
-void FindRegistrationForPattern(
-    scoped_refptr<ServiceWorkerContextWrapper> context,
-    const GURL& scope,
-    const ServiceWorkerStorage::FindRegistrationCallback callback) {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
-    BrowserThread::PostTask(
-        BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(FindRegistrationForPattern, context, scope, callback));
-    return;
-  }
-
-  if (!context->context()) {
-    callback.Run(SERVICE_WORKER_ERROR_ABORT,
-                 scoped_refptr<ServiceWorkerRegistration>());
-    return;
-  }
-  context->context()->storage()->FindRegistrationForPattern(scope, callback);
-}
-
 void UpdateVersionInfo(const ServiceWorkerVersionInfo& version,
                        DictionaryValue* info) {
   switch (version.running_status) {
     case ServiceWorkerVersion::STOPPED:
       info->SetString("running_status", "STOPPED");
       break;
     case ServiceWorkerVersion::STARTING:
       info->SetString("running_status", "STARTING");
       break;
     case ServiceWorkerVersion::RUNNING:
@@ skipping 75 matching lines @@
     result->Append(info);
   }
   return result;
 }
 
 void DidGetStoredRegistrationsOnIOThread(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GetRegistrationsCallback& callback,
     const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!context->context()) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(callback, std::vector<ServiceWorkerRegistrationInfo>(),
-                   std::vector<ServiceWorkerVersionInfo>(),
-                   std::vector<ServiceWorkerRegistrationInfo>()));
-    return;
-  }
-
   BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(callback,
-                 context->context()->GetAllLiveRegistrationInfo(),
-                 context->context()->GetAllLiveVersionInfo(),
-                 stored_registrations));
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(callback, context->GetAllLiveRegistrationInfo(),
+                 context->GetAllLiveVersionInfo(), stored_registrations));
 }
 
 void GetRegistrationsOnIOThread(
     scoped_refptr<ServiceWorkerContextWrapper> context,
     const GetRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!context->context()) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(callback, std::vector<ServiceWorkerRegistrationInfo>(),
-                   std::vector<ServiceWorkerVersionInfo>(),
-                   std::vector<ServiceWorkerRegistrationInfo>()));
-    return;
-  }
-  context->context()->storage()->GetAllRegistrations(
+  context->GetAllRegistrations(
       base::Bind(DidGetStoredRegistrationsOnIOThread, context, callback));
 }
 
 void DidGetRegistrations(
     WeakPtr<ServiceWorkerInternalsUI> internals,
     int partition_id,
     const base::FilePath& context_path,
     const std::vector<ServiceWorkerRegistrationInfo>& live_registrations,
     const std::vector<ServiceWorkerVersionInfo>& live_versions,
     const std::vector<ServiceWorkerRegistrationInfo>& stored_registrations) {
@@ skipping 362 matching lines @@
       !cmd_args->GetInteger("partition_id", &partition_id) ||
       !GetServiceWorkerContext(partition_id, &context) ||
       !cmd_args->GetString("scope", &scope_string)) {
     return;
   }
   base::Callback<void(ServiceWorkerStatusCode)> callback =
       base::Bind(OperationCompleteCallback, AsWeakPtr(), callback_id);
   context->StartServiceWorker(GURL(scope_string), callback);
 }
 
+void ServiceWorkerInternalsUI::UnregisterWithScope(
+    scoped_refptr<ServiceWorkerContextWrapper> context,
+    const GURL& scope,
+    const ServiceWorkerInternalsUI::StatusCallback& callback) const {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&ServiceWorkerInternalsUI::UnregisterWithScope,
+                   base::Unretained(this), context, scope, callback));
+    return;
+  }
+
+  if (!context->context()) {
+    callback.Run(SERVICE_WORKER_ERROR_ABORT);
+    return;
+  }
+
+  // ServiceWorkerContextWrapper::UnregisterServiceWorker doesn't work here
+  // because that reduces a status code to boolean.
+  context->context()->UnregisterServiceWorker(scope, callback);
+}
+
 }  // namespace content