[ServiceWorkerCache] Implement storage::QuotaClient

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"
 #include "base/memory/ref_counted.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/blob/blob_storage_context.h"
 
 namespace content {
 
+const char ServiceWorkerCacheStorage::kIndexFileName[] = "index.txt";
 
 // Handles the loading and clean up of ServiceWorkerCache objects. The
 // callback of every public method is guaranteed to be called.
 class ServiceWorkerCacheStorage::CacheLoader {
  public:
   typedef base::Callback<void(const scoped_refptr<ServiceWorkerCache>&)>
       CacheCallback;
   typedef base::Callback<void(bool)> BoolCallback;
   typedef base::Callback<void(scoped_ptr<std::vector<std::string> >)>
       StringVectorCallback;
 
   CacheLoader(base::SequencedTaskRunner* cache_task_runner,
               net::URLRequestContext* request_context,
-              base::WeakPtr<storage::BlobStorageContext> blob_context)
+              base::WeakPtr<storage::BlobStorageContext> blob_context,
+              const GURL& origin)
       : cache_task_runner_(cache_task_runner),
         request_context_(request_context),
-        blob_context_(blob_context) {}
+        blob_context_(blob_context),
+        origin_(origin) {
+    DCHECK(!origin_.is_empty());
+  }
 
   virtual ~CacheLoader() {}
 
   // Creates a ServiceWorkerCache with the given name. It does not attempt to
   // load the backend, that happens lazily when the cache is used.
   virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) = 0;
 
   // 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 StringVector& 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 StringVectorCallback& callback) = 0;
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   net::URLRequestContext* request_context_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
+  GURL origin_;
 };
 
 // Creates memory-only ServiceWorkerCaches. Because these caches have no
 // persistent storage it is not safe to free them from memory if they might be
 // used again. Therefore this class holds a reference to each cache until the
 // cache is deleted.
 class ServiceWorkerCacheStorage::MemoryLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
   MemoryLoader(base::SequencedTaskRunner* cache_task_runner,
                net::URLRequestContext* request_context,
-               base::WeakPtr<storage::BlobStorageContext> blob_context)
-      : CacheLoader(cache_task_runner, request_context, blob_context) {}
+               base::WeakPtr<storage::BlobStorageContext> blob_context,
+               const GURL& origin)
+      : CacheLoader(cache_task_runner, request_context, blob_context, origin) {}
 
   virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) override {
     return ServiceWorkerCache::CreateMemoryCache(request_context_,
                                                  blob_context_);
   }
 
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) override {
     scoped_refptr<ServiceWorkerCache> cache =
@@ skipping 29 matching lines @@
   // freed.
   CacheRefMap cache_refs_;
 };
 
 class ServiceWorkerCacheStorage::SimpleCacheLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
   SimpleCacheLoader(const base::FilePath& origin_path,
                     base::SequencedTaskRunner* cache_task_runner,
                     net::URLRequestContext* request_context,
-                    base::WeakPtr<storage::BlobStorageContext> blob_context)
-      : CacheLoader(cache_task_runner, request_context, blob_context),
+                    base::WeakPtr<storage::BlobStorageContext> blob_context,
+                    const GURL& origin)
+      : CacheLoader(cache_task_runner, request_context, blob_context, origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
   virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     return ServiceWorkerCache::CreatePersistentCache(
         CreatePersistentCachePath(origin_path_, cache_name),
         request_context_,
@@ skipping 64 matching lines @@
   }
 
   virtual void WriteIndex(const StringVector& cache_names,
                           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;
+    index.set_origin(origin_.spec());
 
     for (size_t i = 0u, max = cache_names.size(); i < max; ++i) {
       ServiceWorkerCacheStorageIndex::Cache* index_cache = index.add_cache();
       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");
+    base::FilePath index_path =
+        origin_path_.AppendASCII(ServiceWorkerCacheStorage::kIndexFileName);
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::WriteIndexWriteToFileInPool,
                    tmp_path,
                    index_path,
                    serialized,
                    callback,
                    base::MessageLoopProxy::current()));
   }
@@ skipping 15 matching lines @@
     original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
   virtual void LoadIndex(scoped_ptr<std::vector<std::string> > names,
                          const StringVectorCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Read the file from disk. (LoadIndexReadFileInPool)
     // 2. Parse file and return the names of the caches (LoadIndexDidReadFile)
 
-    base::FilePath index_path = origin_path_.AppendASCII("index.txt");
+    base::FilePath index_path =
+        origin_path_.AppendASCII(ServiceWorkerCacheStorage::kIndexFileName);
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::LoadIndexReadFileInPool,
                    index_path,
                    base::Passed(names.Pass()),
                    callback,
                    base::MessageLoopProxy::current()));
   }
 
@@ skipping 49 matching lines @@
   const base::FilePath origin_path_;
 
   base::WeakPtrFactory<SimpleCacheLoader> weak_ptr_factory_;
 };
 
 ServiceWorkerCacheStorage::ServiceWorkerCacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
     net::URLRequestContext* request_context,
-    base::WeakPtr<storage::BlobStorageContext> blob_context)
+    base::WeakPtr<storage::BlobStorageContext> blob_context,
+    const GURL& origin)
     : initialized_(false),
       origin_path_(path),
       cache_task_runner_(cache_task_runner),
       memory_only_(memory_only),
       weak_factory_(this) {
   if (memory_only)
     cache_loader_.reset(new MemoryLoader(
-        cache_task_runner_.get(), request_context, blob_context));
+        cache_task_runner_.get(), request_context, blob_context, origin));
   else
-    cache_loader_.reset(new SimpleCacheLoader(
-        origin_path_, cache_task_runner_.get(), request_context, blob_context));
+    cache_loader_.reset(new SimpleCacheLoader(origin_path_,
+                                              cache_task_runner_.get(),
+                                              request_context,
+                                              blob_context,
+                                              origin));
 }
 
 ServiceWorkerCacheStorage::~ServiceWorkerCacheStorage() {
 }
 
 void ServiceWorkerCacheStorage::CreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::CreateCache,
@@ skipping 131 matching lines @@
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::EnumerateCaches,
                         weak_factory_.GetWeakPtr(),
                         callback));
     return;
   }
 
   callback.Run(ordered_cache_names_, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
+void ServiceWorkerCacheStorage::CloseAllCaches() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (!initialized_)
+    return;
+
+  for (auto& key_value : cache_map_) {
+    if (key_value.second)
+      key_value.second->Close();
+  }
+}
+
 // 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
   // has already started.
   if (init_callbacks_.size() > 1u)
@@ skipping 103 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