Refactor job coordination into a separate class.

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_register_job.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/public/browser/browser_thread.h"
 #include "webkit/browser/quota/quota_manager.h"
 
 namespace {
 // This is temporary until we figure out how registration ids will be
 // calculated.
 int64 NextRegistrationId() {
   static int64 worker_id = 0;
   return worker_id++;
 }
 }  // namespace
 
 namespace content {
 
 const base::FilePath::CharType kServiceWorkerDirectory[] =
     FILE_PATH_LITERAL("ServiceWorker");
 
 ServiceWorkerStorage::ServiceWorkerStorage(
     const base::FilePath& path,
     quota::QuotaManagerProxy* quota_manager_proxy)
-    : quota_manager_proxy_(quota_manager_proxy), weak_factory_(this) {
+    : quota_manager_proxy_(quota_manager_proxy) {
   if (!path.empty())
     path_ = path.Append(kServiceWorkerDirectory);
 }
 
 ServiceWorkerStorage::~ServiceWorkerStorage() {
   for (PatternToRegistrationMap::const_iterator iter =
            registration_by_pattern_.begin();
        iter != registration_by_pattern_.end();
        ++iter) {
     iter->second->Shutdown();
@@ skipping 45 matching lines @@
   }
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(callback,
                  false /* found */,
                  REGISTRATION_OK,
                  scoped_refptr<ServiceWorkerRegistration>()));
 }
 
-void ServiceWorkerStorage::Register(const GURL& pattern,
-                                    const GURL& script_url,
-                                    const RegistrationCallback& callback) {
-  scoped_ptr<ServiceWorkerRegisterJob> job(new ServiceWorkerRegisterJob(
-      weak_factory_.GetWeakPtr(),
-      base::Bind(&ServiceWorkerStorage::RegisterComplete,
-                 weak_factory_.GetWeakPtr(),
-                 callback)));
-  job->StartRegister(pattern, script_url);
-  registration_jobs_.push_back(job.release());
-}
-
-void ServiceWorkerStorage::Unregister(const GURL& pattern,
-                                      const UnregistrationCallback& callback) {
-  scoped_ptr<ServiceWorkerRegisterJob> job(new ServiceWorkerRegisterJob(
-      weak_factory_.GetWeakPtr(),
-      base::Bind(&ServiceWorkerStorage::UnregisterComplete,
-                 weak_factory_.GetWeakPtr(),
-                 callback)));
-  job->StartUnregister(pattern);
-  registration_jobs_.push_back(job.release());
-}
-
 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() ||
          current->second->script_url() == script_url);
 
   if (current == registration_by_pattern_.end()) {
@@ skipping 23 matching lines @@
   // TODO(alecflett): Formalize what pattern matches mean.
   // 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);
 }
 
-void ServiceWorkerStorage::EraseJob(ServiceWorkerRegisterJob* job) {
-  ScopedVector<ServiceWorkerRegisterJob>::iterator job_position =
-      registration_jobs_.begin();
-  for (; job_position != registration_jobs_.end(); ++job_position) {
-    if (*job_position == job) {
-      registration_jobs_.erase(job_position);
-      return;
-    }
-  }
-  NOTREACHED() << "Deleting non-existent job. ";
-}
-
-void ServiceWorkerStorage::UnregisterComplete(
-    const UnregistrationCallback& callback,
-    ServiceWorkerRegisterJob* job,
-    ServiceWorkerRegistrationStatus status,
-    ServiceWorkerRegistration* previous_registration) {
-  callback.Run(status);
-  EraseJob(job);
-}
-
-void ServiceWorkerStorage::RegisterComplete(
-    const RegistrationCallback& callback,
-    ServiceWorkerRegisterJob* job,
-    ServiceWorkerRegistrationStatus status,
-    ServiceWorkerRegistration* registration) {
-  callback.Run(status, registration);
-  EraseJob(job);
-}
-
 }  // namespace content