Sort ServiceWorkerCacheStorage::Keys() by creation order.

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/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 39 matching lines @@
   // Deletes any pre-existing cache of the same name and then loads it.
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) = 0;
 
   // After the backend has been deleted, do any extra house keeping such as
   // removing the cache's directory.
   virtual void CleanUpDeletedCache(const std::string& key,
                                    const BoolCallback& callback) = 0;
 
   // Writes the cache names (and sizes) to disk if applicable.
-  virtual void WriteIndex(const CacheMap& caches,
+  virtual void WriteIndex(const ServiceWorkerCacheStorage::Strings& cache_names,
                           const BoolCallback& callback) = 0;
 
   // Loads the cache names from disk if applicable.
   virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
                          const StringsCallback& callback) = 0;
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   net::URLRequestContext* request_context_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
@@ skipping 26 matching lines @@
   }
 
   virtual void CleanUpDeletedCache(const std::string& cache_name,
                                    const BoolCallback& callback) OVERRIDE {
     CacheRefMap::iterator it = cache_refs_.find(cache_name);
     DCHECK(it != cache_refs_.end());
     cache_refs_.erase(it);
     callback.Run(true);
   }
 
-  virtual void WriteIndex(const CacheMap& caches,
+  virtual void WriteIndex(const ServiceWorkerCacheStorage::Strings& cache_names,
                           const BoolCallback& callback) OVERRIDE {
     callback.Run(false);
   }
 
   virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
                          const StringsCallback& callback) OVERRIDE {
     callback.Run(cache_names.Pass());
   }
 
  private:
@@ skipping 83 matching lines @@
   }
 
   static void CleanUpDeleteCacheDirInPool(
       const base::FilePath& cache_path,
       const BoolCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
     bool rv = base::DeleteFile(cache_path, true);
     original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
-  virtual void WriteIndex(const CacheMap& caches,
+  virtual void WriteIndex(const ServiceWorkerCacheStorage::Strings& cache_names,

[michaeln, 2014/09/12 21:45:32]

is the fully qualification needed given that CacheLoaders are nested classes?

[jkarlin, 2014/09/15 14:14:29]

Done.

                           const BoolCallback& callback) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Create the index file as a string. (WriteIndex)
     // 2. Write the file to disk. (WriteIndexWriteToFileInPool)
 
     ServiceWorkerCacheStorageIndex index;
 
-    for (CacheMap::const_iterator it = caches.begin(); it != caches.end();
-         ++it) {
+    for (size_t i = 0u, max = cache_names.size(); i < max; ++i) {
       ServiceWorkerCacheStorageIndex::Cache* index_cache = index.add_cache();
-      index_cache->set_name(it->first);
+      index_cache->set_name(cache_names[i]);
       index_cache->set_size(0);  // TODO(jkarlin): Make this real.
     }
 
     std::string serialized;
     bool success = index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
     base::FilePath index_path = origin_path_.AppendASCII("index.txt");
 
@@ skipping 201 matching lines @@
     callback.Run(false, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   base::WeakPtr<ServiceWorkerCache> cache = it->second;
   if (cache)
     cache->Close();
 
   cache_map_.erase(it);
 
+  // Delete the name from ordered_cache_names_.
+  Strings::iterator iter = std::find(
+      ordered_cache_names_.begin(), ordered_cache_names_.end(), cache_name);
+  DCHECK(iter != ordered_cache_names_.end());
+  ordered_cache_names_.erase(iter);
+
   // Update the Index
   cache_loader_->WriteIndex(
-      cache_map_,
+      ordered_cache_names_,
       base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(),
                  cache_name,
                  callback));
 }
 
 void ServiceWorkerCacheStorage::EnumerateCaches(
     const StringsAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::EnumerateCaches,
                         weak_factory_.GetWeakPtr(),
                         callback));
     return;
   }
 
-  std::vector<std::string> names;
-  for (CacheMap::const_iterator it = cache_map_.begin(); it != cache_map_.end();
-       ++it) {
-    names.push_back(it->first);
-  }
-
-  callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(ordered_cache_names_, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 // Init is run lazily so that it is called on the proper MessageLoop.
 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
@@ skipping 17 matching lines @@
 }
 
 void ServiceWorkerCacheStorage::LazyInitDidLoadIndex(
     const base::Closure& callback,
     scoped_ptr<std::vector<std::string> > indexed_cache_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   for (size_t i = 0u, max = indexed_cache_names->size(); i < max; ++i) {
     cache_map_.insert(std::make_pair(indexed_cache_names->at(i),
                                      base::WeakPtr<ServiceWorkerCache>()));
+    ordered_cache_names_.push_back(indexed_cache_names->at(i));
   }
 
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 void ServiceWorkerCacheStorage::CreateCacheDidCreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback,
     const scoped_refptr<ServiceWorkerCache>& cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!cache.get()) {
     callback.Run(scoped_refptr<ServiceWorkerCache>(),
                  CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
 
   cache_map_.insert(std::make_pair(cache_name, cache->AsWeakPtr()));
+  ordered_cache_names_.push_back(cache_name);
 
   cache_loader_->WriteIndex(
-      cache_map_,
+      ordered_cache_names_,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  cache));
 }
 
 void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     const scoped_refptr<ServiceWorkerCache>& cache,
     bool success) {
@@ skipping 39 matching lines @@
     scoped_refptr<ServiceWorkerCache> new_cache =
         cache_loader_->CreateServiceWorkerCache(cache_name);
     map_iter->second = new_cache->AsWeakPtr();
     return new_cache;
   }
 
   return make_scoped_refptr(cache.get());
 }
 
 }  // namespace content