Have a central operation status code for ServiceWorker

content/browser/service_worker/service_worker_storage.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_storage.h"
 
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_registration.h"
@@ skipping 36 matching lines @@
     const GURL& pattern,
     const FindRegistrationCallback& callback) {
   PatternToRegistrationMap::const_iterator match =
       registration_by_pattern_.find(pattern);
   if (match == registration_by_pattern_.end()) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(callback,
                    false /* found */,
-                   REGISTRATION_OK,
+                   SERVICE_WORKER_OK,
                    scoped_refptr<ServiceWorkerRegistration>()));
     return;
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(callback, true /* found */, REGISTRATION_OK, match->second));
+      base::Bind(callback, true /* found */, SERVICE_WORKER_OK, match->second));
 }
 
 void ServiceWorkerStorage::FindRegistrationForDocument(
     const GURL& document_url,
     const FindRegistrationCallback& callback) {
   // TODO(alecflett): This needs to be synchronous in the fast path,
   // but asynchronous in the slow path (when the patterns have to be
   // loaded from disk). For now it is always pessimistically async.
   for (PatternToRegistrationMap::const_iterator it =
            registration_by_pattern_.begin();
        it != registration_by_pattern_.end();
        ++it) {
     if (PatternMatches(it->first, document_url)) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
           base::Bind(callback,
                      true /* found */,
-                     REGISTRATION_OK,
+                     SERVICE_WORKER_OK,
                      scoped_refptr<ServiceWorkerRegistration>(it->second)));
       return;
     }
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback,
                  false /* found */,
-                 REGISTRATION_OK,
+                 SERVICE_WORKER_OK,
                  scoped_refptr<ServiceWorkerRegistration>()));
 }
 
 scoped_refptr<ServiceWorkerRegistration> ServiceWorkerStorage::RegisterInternal(
     const GURL& pattern,
     const GURL& script_url) {
 
   PatternToRegistrationMap::const_iterator current(
       registration_by_pattern_.find(pattern));
   DCHECK(current == registration_by_pattern_.end() ||
@@ skipping 27 matching lines @@
   // Temporarily borrowed directly from appcache::Namespace::IsMatch().
   // We have to escape '?' characters since MatchPattern also treats those
   // as wildcards which we don't want here, we only do '*'s.
   std::string pattern_spec(pattern.spec());
   if (pattern.has_query())
     ReplaceSubstringsAfterOffset(&pattern_spec, 0, "?", "\\?");
   return MatchPattern(url.spec(), pattern_spec);
 }
 
 }  // namespace content