Service Worker: Make ServiceWorkerRegistration.update() return a promise. (Chromium 2/3)

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 "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
@@ skipping 253 matching lines @@
   job_coordinator_->Register(
       pattern,
       script_url,
       provider_host,
       base::Bind(&ServiceWorkerContextCore::RegistrationComplete,
                  AsWeakPtr(),
                  pattern,
                  callback));
 }
 
+void ServiceWorkerContextCore::UpdateServiceWorker(
+    ServiceWorkerRegistration* registration,
+    bool force_bypass_cache) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (storage()->IsDisabled())
+    return;
+
+  job_coordinator_->Update(registration, force_bypass_cache);
+}
+
+void ServiceWorkerContextCore::UpdateServiceWorker(
+    ServiceWorkerRegistration* registration,
+    bool force_bypass_cache,
+    ServiceWorkerProviderHost* provider_host,
+    const UpdateCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (storage()->IsDisabled()) {
+    callback.Run(SERVICE_WORKER_ERROR_ABORT, std::string(),
+                 kInvalidServiceWorkerRegistrationId);
+    return;
+  }
+
+  job_coordinator_->Update(registration, force_bypass_cache, provider_host,
+                           base::Bind(&ServiceWorkerContextCore::UpdateComplete,
+                                      AsWeakPtr(), callback));
+}
+
 void ServiceWorkerContextCore::UnregisterServiceWorker(
     const GURL& pattern,
     const UnregistrationCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (storage()->IsDisabled()) {
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
 
   job_coordinator_->Unregister(
@@ skipping 34 matching lines @@
       scopes.size(),
       base::Bind(
           &SuccessReportingCallback, base::Owned(overall_success), result));
 
   for (const GURL& scope : scopes) {
     UnregisterServiceWorker(
         scope, base::Bind(&SuccessCollectorCallback, barrier, overall_success));
   }
 }
 
-void ServiceWorkerContextCore::UpdateServiceWorker(
-    ServiceWorkerRegistration* registration,
-    bool force_bypass_cache) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (storage()->IsDisabled())
-    return;
-  job_coordinator_->Update(registration, force_bypass_cache);
-}
-
 void ServiceWorkerContextCore::RegistrationComplete(
     const GURL& pattern,
     const ServiceWorkerContextCore::RegistrationCallback& 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());
   // 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);
   }
 }
 
+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 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);
@@ skipping 219 matching lines @@
   observer_list_->Notify(FROM_HERE,
                          &ServiceWorkerContextObserver::OnControlleeRemoved,
                          version->version_id(), provider_host->client_uuid());
 }
 
 ServiceWorkerProcessManager* ServiceWorkerContextCore::process_manager() {
   return wrapper_->process_manager();
 }
 
 }  // namespace content