[ServiceWorkerCache] Call QuotaManager::NotifyStorageModified from Cache.

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"
+#include "storage/browser/quota/quota_manager_proxy.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,
-              const GURL& origin)
+  CacheLoader(
+      base::SequencedTaskRunner* cache_task_runner,
+      net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
+      base::WeakPtr<storage::BlobStorageContext> blob_context,
+      const GURL& origin)
       : cache_task_runner_(cache_task_runner),
         request_context_(request_context),
+        quota_manager_proxy_(quota_manager_proxy),
         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(
@@ skipping 12 matching lines @@
   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_;
+  scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   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,
-               const GURL& origin)
-      : CacheLoader(cache_task_runner, request_context, blob_context, origin) {}
+  MemoryLoader(
+      base::SequencedTaskRunner* cache_task_runner,
+      net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
+      base::WeakPtr<storage::BlobStorageContext> blob_context,
+      const GURL& origin)
+      : CacheLoader(cache_task_runner,
+                    request_context,
+                    quota_manager_proxy,
+                    blob_context,
+                    origin) {}
 
   scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) override {
-    return ServiceWorkerCache::CreateMemoryCache(request_context_,
-                                                 blob_context_);
+    return ServiceWorkerCache::CreateMemoryCache(
+        origin_, request_context_, quota_manager_proxy_, blob_context_);
   }
 
   void CreateCache(const std::string& cache_name,
                    const CacheCallback& callback) override {
     scoped_refptr<ServiceWorkerCache> cache =
-        ServiceWorkerCache::CreateMemoryCache(request_context_, blob_context_);
+        CreateServiceWorkerCache(cache_name);
     cache_refs_.insert(std::make_pair(cache_name, cache));
     callback.Run(cache);
   }
 
   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);
@@ skipping 15 matching lines @@
 
   // Keep a reference to each cache to ensure that it's not freed before the
   // client calls ServiceWorkerCacheStorage::Delete or the CacheStorage is
   // 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,
-                    const GURL& origin)
-      : CacheLoader(cache_task_runner, request_context, blob_context, origin),
+  SimpleCacheLoader(
+      const base::FilePath& origin_path,
+      base::SequencedTaskRunner* cache_task_runner,
+      net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
+      base::WeakPtr<storage::BlobStorageContext> blob_context,
+      const GURL& origin)
+      : CacheLoader(cache_task_runner,
+                    request_context,
+                    quota_manager_proxy,
+                    blob_context,
+                    origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
   scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     return ServiceWorkerCache::CreatePersistentCache(
+        origin_,
         CreatePersistentCachePath(origin_path_, cache_name),
         request_context_,
+        quota_manager_proxy_,
         blob_context_);
   }
 
   void CreateCache(const std::string& cache_name,
                    const CacheCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Delete the cache's directory if it exists.
     // (CreateCacheDeleteFilesInPool)
     // 2. Load the cache. (LoadCreateDirectoryInPool)
@@ skipping 175 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,
+    const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     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, origin));
+    cache_loader_.reset(new MemoryLoader(cache_task_runner_.get(),
+                                         request_context,
+                                         quota_manager_proxy,
+                                         blob_context,
+                                         origin));
   else
     cache_loader_.reset(new SimpleCacheLoader(origin_path_,
                                               cache_task_runner_.get(),
                                               request_context,
+                                              quota_manager_proxy,
                                               blob_context,
                                               origin));
 }
 
 ServiceWorkerCacheStorage::~ServiceWorkerCacheStorage() {
 }
 
 void ServiceWorkerCacheStorage::OpenCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
@@ skipping 220 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