Have a central operation status code for ServiceWorker

content/browser/service_worker/service_worker_register_job.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_register_job.h"
 
 #include <vector>
 
 #include "content/browser/service_worker/service_worker_job_coordinator.h"
 #include "content/browser/service_worker/service_worker_registration.h"
@@ skipping 64 matching lines @@
   ServiceWorkerStorage::FindRegistrationCallback unregister(
       base::Bind(&ServiceWorkerRegisterJob::UnregisterPatternAndContinue,
                  weak_factory_.GetWeakPtr(),
                  finish_unregistration));
 
   storage_->FindRegistrationForPattern(pattern_, unregister);
 }
 
 void ServiceWorkerRegisterJob::RegisterPatternAndContinue(
     const RegistrationCallback& callback,
-    ServiceWorkerRegistrationStatus previous_status) {
-  if (previous_status != REGISTRATION_OK) {
+    ServiceWorkerStatusCode previous_status) {
+  if (previous_status != SERVICE_WORKER_OK) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(callback,
                    previous_status,
                    scoped_refptr<ServiceWorkerRegistration>()));
     return;
   }
 
   // TODO: Eventually RegisterInternal will be replaced by an asynchronous
   // operation. Pass its resulting status through 'callback'.
   scoped_refptr<ServiceWorkerRegistration> registration =
       storage_->RegisterInternal(pattern_, script_url_);
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
-                          base::Bind(callback, REGISTRATION_OK, registration));
+                          base::Bind(callback, SERVICE_WORKER_OK,
+                                     registration));
 }
 
 void ServiceWorkerRegisterJob::UnregisterPatternAndContinue(
     const UnregistrationCallback& callback,
     bool found,
-    ServiceWorkerRegistrationStatus previous_status,
+    ServiceWorkerStatusCode previous_status,
     const scoped_refptr<ServiceWorkerRegistration>& previous_registration) {
 
   // The previous registration may not exist, which is ok.
-  if (previous_status == REGISTRATION_OK && found &&
+  if (previous_status == SERVICE_WORKER_OK && found &&
       (script_url_.is_empty() ||
        previous_registration->script_url() != script_url_)) {
     // TODO: Eventually UnregisterInternal will be replaced by an
     // asynchronous operation. Pass its resulting status though
     // 'callback'.
     storage_->UnregisterInternal(pattern_);
     DCHECK(previous_registration->is_shutdown());
   }
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE, base::Bind(callback, previous_status));
 }
 
 void ServiceWorkerRegisterJob::RunCallbacks(
-    ServiceWorkerRegistrationStatus status,
+    ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   for (std::vector<RegistrationCallback>::iterator it = callbacks_.begin();
        it != callbacks_.end();
        ++it) {
     it->Run(status, registration);
   }
 }
 void ServiceWorkerRegisterJob::RegisterComplete(
-    ServiceWorkerRegistrationStatus status,
+    ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& registration) {
   RunCallbacks(status, registration);
   coordinator_->FinishJob(pattern_, this);
 }
 
 void ServiceWorkerRegisterJob::UnregisterComplete(
-    ServiceWorkerRegistrationStatus status) {
+    ServiceWorkerStatusCode status) {
   RunCallbacks(status, NULL);
   coordinator_->FinishJob(pattern_, this);
 }
 
 }  // namespace content