Initial implementation of ServiceWorkerCache.

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 46 matching lines @@
   virtual void WriteIndex(CacheMap* caches, 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:
   friend class base::RefCountedThreadSafe<
       ServiceWorkerCacheStorage::CacheLoader>;
 
-  virtual ~CacheLoader() {};
+  virtual ~CacheLoader() {}
   virtual void LoadCacheImpl(const std::string&) {}
 
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   net::URLRequestContext* request_context_;
   base::WeakPtr<webkit_blob::BlobStorageContext> blob_context_;
 };
 
 class ServiceWorkerCacheStorage::MemoryLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
@@ skipping 259 matching lines @@
                                        callback,
                                        body));
   }
 
   void LoadIndexDidReadFile(scoped_ptr<std::vector<std::string> > names,
                             const StringsCallback& callback,
                             const std::string& serialized) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     ServiceWorkerCacheStorageIndex index;
-    index.ParseFromString(serialized);
-
-    for (int i = 0, max = index.cache_size(); i < max; ++i) {
-      const ServiceWorkerCacheStorageIndex::Cache& cache = index.cache(i);
-      names->push_back(cache.name());
+    if (index.ParseFromString(serialized)) {
+      for (int i = 0, max = index.cache_size(); i < max; ++i) {
+        const ServiceWorkerCacheStorageIndex::Cache& cache = index.cache(i);
+        names->push_back(cache.name());
+      }
     }
 
     // TODO(jkarlin): Delete caches that are in the directory and not returned
     // in LoadIndex.
     callback.Run(names.Pass());
   }
 
  private:
   virtual ~SimpleCacheLoader() {}
 
@@ skipping 79 matching lines @@
     callback.Run(0, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
   ServiceWorkerCache* cache = GetLoadedCache(cache_name);
   if (!cache) {
     callback.Run(0, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
+  if (cache->HasCreatedBackend())
+    return callback.Run(cache->id(), CACHE_STORAGE_ERROR_NO_ERROR);
+
   cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
                                   weak_factory_.GetWeakPtr(),
                                   cache->AsWeakPtr(),
                                   callback));
 }
 
 void ServiceWorkerCacheStorage::HasCache(const std::string& cache_name,
                                          const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 67 matching lines @@
        ++it) {
     names.push_back(it->first);
   }
 
   callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DidCreateBackend(
     base::WeakPtr<ServiceWorkerCache> cache,
     const CacheAndErrorCallback& callback,
-    bool success) {
+    ServiceWorkerCache::ErrorType error) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (!success || !cache) {
+  if (error != ServiceWorkerCache::ErrorTypeOK || !cache) {
     // TODO(jkarlin): This should delete the directory and try again in case
     // the cache is simply corrupt.
     callback.Run(0, CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
+
   callback.Run(cache->id(), 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);
 
@@ skipping 110 matching lines @@
 
 void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     base::WeakPtr<ServiceWorkerCache> cache,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!cache) {
     callback.Run(false, CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
+
   cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
                                   weak_factory_.GetWeakPtr(),
                                   cache,
                                   callback));
 }
 
 void ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback,
     bool success) {
@@ skipping 22 matching lines @@
   NameMap::const_iterator it = name_map_.find(cache_name);
   if (it == name_map_.end())
     return NULL;
 
   ServiceWorkerCache* cache = cache_map_.Lookup(it->second);
   DCHECK(cache);
   return cache;
 }
 
 }  // namespace content