Organize ServiceWorkerCacheStorage's methods.

content/browser/service_worker/service_worker_cache_storage.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_cache_storage.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 545 matching lines @@
 
   std::vector<std::string> names;
   for (NameMap::const_iterator it = name_map_.begin(); it != name_map_.end();
        ++it) {
     names.push_back(it->first);
   }
 
   callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
-// static
-void ServiceWorkerCacheStorage::DidCreateBackend(
-    base::WeakPtr<ServiceWorkerCache> cache,
-    CacheID cache_id,
-    const CacheAndErrorCallback& callback,
-    ServiceWorkerCache::ErrorType error) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (error != ServiceWorkerCache::ErrorTypeOK || !cache) {
-    // TODO(jkarlin): This should delete the directory and try again in case
-    // the cache is simply corrupt.
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_STORAGE);
-    return;
-  }
-
-  callback.Run(cache_id, CACHE_STORAGE_ERROR_NO_ERROR);
-}
-
 void ServiceWorkerCacheStorage::LazyInit(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!initialized_);
 
   init_callbacks_.push_back(callback);
 
   // If this isn't the first call to LazyInit then return as the initialization
   // has already started.
   if (init_callbacks_.size() > 1u)
     return;
 
   // 1. Get the list of cache names (async call)
   // 2. For each cache name, load the cache (async call)
   // 3. Once each load is complete, update the map variables.
   // 4. Call the list of waiting callbacks.
 
   scoped_ptr<std::vector<std::string> > indexed_cache_names(
       new std::vector<std::string>());
 
   cache_loader_->LoadIndex(
       indexed_cache_names.Pass(),
       base::Bind(&ServiceWorkerCacheStorage::LazyInitDidLoadIndex,
                  callback,
                  weak_factory_.GetWeakPtr()));
 }
 
+ServiceWorkerCacheStorage::CacheContext*
+ServiceWorkerCacheStorage::GetLoadedCache(const std::string& cache_name) const {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(initialized_);
+
+  NameMap::const_iterator name_iter = name_map_.find(cache_name);
+  if (name_iter == name_map_.end())
+    return NULL;
+
+  CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
+  DCHECK(map_iter != cache_map_.end());
+  return map_iter->second;
+}
+
+ServiceWorkerCacheStorage::CacheContext*
+ServiceWorkerCacheStorage::AddCacheToMaps(
+    const std::string& cache_name,
+    scoped_ptr<ServiceWorkerCache> cache) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  CacheID id = next_cache_id_++;
+  CacheContext* cache_context = new CacheContext(cache_name, id, cache.Pass());
+  cache_map_.insert(std::make_pair(id, cache_context));  // Takes ownership
+  name_map_.insert(std::make_pair(cache_name, id));
+  return cache_context;
+}
+
 // static
 void ServiceWorkerCacheStorage::LazyInitDidLoadIndex(
     const base::Closure& callback,
     base::WeakPtr<ServiceWorkerCacheStorage> storage,
     scoped_ptr<std::vector<std::string> > indexed_cache_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!storage)
     return;  // The callbacks were already run by the destructor.
 
@@ skipping 55 matching lines @@
   storage->initialized_ = true;
   for (std::vector<base::Closure>::iterator it =
            storage->init_callbacks_.begin();
        it != storage->init_callbacks_.end();
        ++it) {
     it->Run();
   }
   storage->init_callbacks_.clear();
 }
 
-ServiceWorkerCacheStorage::CacheContext*
-ServiceWorkerCacheStorage::AddCacheToMaps(
-    const std::string& cache_name,
-    scoped_ptr<ServiceWorkerCache> cache) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  CacheID id = next_cache_id_++;
-  CacheContext* cache_context = new CacheContext(cache_name, id, cache.Pass());
-  cache_map_.insert(std::make_pair(id, cache_context));  // Takes ownership
-  name_map_.insert(std::make_pair(cache_name, id));
-  return cache_context;
-}
-
 // static
 void ServiceWorkerCacheStorage::CreateCacheDidCreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback,
     base::WeakPtr<ServiceWorkerCacheStorage> storage,
     scoped_ptr<ServiceWorkerCache> cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!cache || !storage) {
     callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_CLOSING);
@@ skipping 47 matching lines @@
 
 // static
 void ServiceWorkerCacheStorage::DeleteCacheDidCleanUp(
     const BoolAndErrorCallback& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(true, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
-ServiceWorkerCacheStorage::CacheContext*
-ServiceWorkerCacheStorage::GetLoadedCache(const std::string& cache_name) const {
+// static
+void ServiceWorkerCacheStorage::DidCreateBackend(
+    base::WeakPtr<ServiceWorkerCache> cache,
+    CacheID cache_id,
+    const CacheAndErrorCallback& callback,
+    ServiceWorkerCache::ErrorType error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(initialized_);
 
-  NameMap::const_iterator name_iter = name_map_.find(cache_name);
-  if (name_iter == name_map_.end())
-    return NULL;
+  if (error != ServiceWorkerCache::ErrorTypeOK || !cache) {
+    // TODO(jkarlin): This should delete the directory and try again in case
+    // the cache is simply corrupt.
+    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_STORAGE);
+    return;
+  }
 
-  CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
-  DCHECK(map_iter != cache_map_.end());
-  return map_iter->second;
+  callback.Run(cache_id, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 }  // namespace content