[ServiceWorkerCache] Call QuotaManager::NotifyStorageModified from Cache.

With this call the quota manager can delete origins modified in the last X hours.

Changes:
* Plumb origin and QuotaManagerProxy through to ServiceWorkerCache.

* Call NotifyStorageModified on SWCache::Put() and SWCache::Delete() with the delta being the number of content bytes written (not including caching structure overhead).

* Update the tests to use a MockQuotaManagerProxy instead of passing a nullptr.

Upstream of: https://codereview.chromium.org/672943002

BUG=420159

Review URL: https://codereview.chromium.org/674873002

Cr-Commit-Position: refs/heads/master@{#301086}

content/browser/service_worker/service_worker_cache.h

@@ -22,6 +22,7 @@ namespace storage {
 class BlobData;
 class BlobDataHandle;
 class BlobStorageContext;
+class QuotaManagerProxy;
 }
 
 namespace content {
@@ -54,11 +55,15 @@ class CONTENT_EXPORT ServiceWorkerCache
       RequestsCallback;
 
   static scoped_refptr<ServiceWorkerCache> CreateMemoryCache(
+      const GURL& origin,
       net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
   static scoped_refptr<ServiceWorkerCache> CreatePersistentCache(
+      const GURL& origin,
       const base::FilePath& path,
       net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
 
   // Returns ErrorTypeNotFound if not found. The callback will always be called.
@@ -97,9 +102,12 @@ class CONTENT_EXPORT ServiceWorkerCache
   struct KeysContext;
   typedef std::vector<disk_cache::Entry*> Entries;
 
-  ServiceWorkerCache(const base::FilePath& path,
-                     net::URLRequestContext* request_context,
-                     base::WeakPtr<storage::BlobStorageContext> blob_context);
+  ServiceWorkerCache(
+      const GURL& origin,
+      const base::FilePath& path,
+      net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
+      base::WeakPtr<storage::BlobStorageContext> blob_context);
 
   // Operations in progress will complete after the cache is deleted but pending
   // operations (those operations waiting for init to finish) won't.
@@ -130,8 +138,10 @@ class CONTENT_EXPORT ServiceWorkerCache
   // The backend can be deleted via the Close function at any time so always
   // check for its existence before use.
   scoped_ptr<disk_cache::Backend> backend_;
+  GURL origin_;
   base::FilePath path_;
   net::URLRequestContext* request_context_;
+  scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
   bool initialized_;
   std::vector<base::Closure> init_callbacks_;

content/browser/service_worker/service_worker_cache_storage.cc

@@ -19,6 +19,7 @@
 #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 {
 
@@ -34,12 +35,15 @@ class ServiceWorkerCacheStorage::CacheLoader {
   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());
@@ -72,6 +76,7 @@ class ServiceWorkerCacheStorage::CacheLoader {
  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_;
 };
@@ -83,22 +88,28 @@ class ServiceWorkerCacheStorage::CacheLoader {
 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);
   }
@@ -134,12 +145,18 @@ class ServiceWorkerCacheStorage::MemoryLoader
 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) {}
 
@@ -148,8 +165,10 @@ class ServiceWorkerCacheStorage::SimpleCacheLoader
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     return ServiceWorkerCache::CreatePersistentCache(
+        origin_,
         CreatePersistentCachePath(origin_path_, cache_name),
         request_context_,
+        quota_manager_proxy_,
         blob_context_);
   }
 
@@ -345,6 +364,7 @@ ServiceWorkerCacheStorage::ServiceWorkerCacheStorage(
     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),
@@ -353,12 +373,16 @@ ServiceWorkerCacheStorage::ServiceWorkerCacheStorage(
       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));
 }

content/browser/service_worker/service_worker_cache_storage.h

@@ -56,6 +56,7 @@ class CONTENT_EXPORT ServiceWorkerCacheStorage {
       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);
 

content/browser/service_worker/service_worker_cache_storage_manager.cc

@@ -88,7 +88,7 @@ scoped_ptr<ServiceWorkerCacheStorageManager>
 ServiceWorkerCacheStorageManager::Create(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
-    storage::QuotaManagerProxy* quota_manager_proxy) {
+    const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy) {
   base::FilePath root_path = path;
   if (!path.empty()) {
     root_path = path.Append(ServiceWorkerContextCore::kServiceWorkerDirectory)
@@ -260,15 +260,16 @@ void ServiceWorkerCacheStorageManager::DeleteOriginData(
 ServiceWorkerCacheStorageManager::ServiceWorkerCacheStorageManager(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
-    storage::QuotaManagerProxy* quota_manager_proxy)
+    const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
     : root_path_(path),
       cache_task_runner_(cache_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
       request_context_(NULL),
       weak_ptr_factory_(this) {
-  if (quota_manager_proxy_.get())
+  if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->RegisterClient(
         new ServiceWorkerCacheQuotaClient(weak_ptr_factory_.GetWeakPtr()));
+  }
 }
 
 ServiceWorkerCacheStorage*
@@ -276,7 +277,6 @@ ServiceWorkerCacheStorageManager::FindOrCreateServiceWorkerCacheManager(
     const GURL& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(request_context_);
-
   ServiceWorkerCacheStorageMap::const_iterator it =
       cache_storage_map_.find(origin);
   if (it == cache_storage_map_.end()) {
@@ -285,6 +285,7 @@ ServiceWorkerCacheStorageManager::FindOrCreateServiceWorkerCacheManager(
                                       IsMemoryBacked(),
                                       cache_task_runner_.get(),
                                       request_context_,
+                                      quota_manager_proxy_,
                                       blob_context_,
                                       origin);
     // The map owns fetch_stores.

content/browser/service_worker/service_worker_cache_storage_manager.h

@@ -41,7 +41,7 @@ class CONTENT_EXPORT ServiceWorkerCacheStorageManager {
   static scoped_ptr<ServiceWorkerCacheStorageManager> Create(
       const base::FilePath& path,
       const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
-      storage::QuotaManagerProxy* quota_manager_proxy);
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy);
 
   static scoped_ptr<ServiceWorkerCacheStorageManager> Create(
       ServiceWorkerCacheStorageManager* old_manager);
@@ -86,7 +86,7 @@ class CONTENT_EXPORT ServiceWorkerCacheStorageManager {
   ServiceWorkerCacheStorageManager(
       const base::FilePath& path,
       const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
-      storage::QuotaManagerProxy* quota_manager_proxy);
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy);
 
   // The returned ServiceWorkerCacheStorage* is owned by
   // service_worker_cache_storages_.

content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc

@@ -9,12 +9,14 @@
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
+#include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/browser/service_worker/service_worker_cache_quota_client.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
@@ -36,15 +38,22 @@ class ServiceWorkerCacheStorageManagerTest : public testing::Test {
     // Wait for ChromeBlobStorageContext to finish initializing.
     base::RunLoop().RunUntilIdle();
 
+    quota_manager_proxy_ = new MockQuotaManagerProxy(
+        nullptr, base::MessageLoopProxy::current().get());
+
     net::URLRequestContext* url_request_context =
         browser_context_.GetRequestContext()->GetURLRequestContext();
     if (MemoryOnly()) {
       cache_manager_ = ServiceWorkerCacheStorageManager::Create(
-          base::FilePath(), base::MessageLoopProxy::current(), nullptr);
+          base::FilePath(),
+          base::MessageLoopProxy::current(),
+          quota_manager_proxy_);
     } else {
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
       cache_manager_ = ServiceWorkerCacheStorageManager::Create(
-          temp_dir_.path(), base::MessageLoopProxy::current(), nullptr);
+          temp_dir_.path(),
+          base::MessageLoopProxy::current(),
+          quota_manager_proxy_);
     }
 
     cache_manager_->SetBlobParametersForCache(
@@ -52,6 +61,7 @@ class ServiceWorkerCacheStorageManagerTest : public testing::Test {
   }
 
   virtual void TearDown() override {
+    quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     base::RunLoop().RunUntilIdle();
   }
 
@@ -205,6 +215,7 @@ class ServiceWorkerCacheStorageManagerTest : public testing::Test {
   TestBrowserThreadBundle browser_thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
+  scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_ptr<ServiceWorkerCacheStorageManager> cache_manager_;
 
   scoped_refptr<ServiceWorkerCache> callback_cache_;
@@ -350,6 +361,7 @@ TEST_F(ServiceWorkerCacheStorageManagerTest, DataPersists) {
   EXPECT_TRUE(Open(origin1_, "baz"));
   EXPECT_TRUE(Open(origin2_, "raz"));
   EXPECT_TRUE(Delete(origin1_, "bar"));
+  quota_manager_proxy_->SimulateQuotaManagerDestroyed();
   cache_manager_ =
       ServiceWorkerCacheStorageManager::Create(cache_manager_.get());
   EXPECT_TRUE(Keys(origin1_));
@@ -363,6 +375,7 @@ TEST_F(ServiceWorkerCacheStorageManagerTest, DataPersists) {
 TEST_F(ServiceWorkerCacheStorageManagerMemoryOnlyTest, DataLostWhenMemoryOnly) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(Open(origin2_, "baz"));
+  quota_manager_proxy_->SimulateQuotaManagerDestroyed();
   cache_manager_ =
       ServiceWorkerCacheStorageManager::Create(cache_manager_.get());
   EXPECT_TRUE(Keys(origin1_));

content/browser/service_worker/service_worker_cache_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/run_loop.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/fileapi/mock_url_request_delegate.h"
+#include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_context.h"
@@ -20,6 +21,7 @@
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/common/blob/blob_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -53,6 +55,9 @@ class ServiceWorkerCacheTest : public testing::Test {
     base::RunLoop().RunUntilIdle();
     blob_storage_context_ = blob_storage_context->context();
 
+    quota_manager_proxy_ = new MockQuotaManagerProxy(
+        nullptr, base::MessageLoopProxy::current().get());
+
     url_request_job_factory_.reset(new net::URLRequestJobFactoryImpl);
     url_request_job_factory_->SetProtocolHandler(
         "blob", CreateMockBlobProtocolHandler(blob_storage_context->context()));
@@ -66,18 +71,23 @@ class ServiceWorkerCacheTest : public testing::Test {
 
     if (MemoryOnly()) {
       cache_ = ServiceWorkerCache::CreateMemoryCache(
+          GURL("http://example.com"),
           url_request_context,
+          quota_manager_proxy_,
           blob_storage_context->context()->AsWeakPtr());
     } else {
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
       cache_ = ServiceWorkerCache::CreatePersistentCache(
+          GURL("http://example.com"),
           temp_dir_.path(),
           url_request_context,
+          quota_manager_proxy_,
           blob_storage_context->context()->AsWeakPtr());
     }
   }
 
   virtual void TearDown() override {
+    quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     base::RunLoop().RunUntilIdle();
   }
 
@@ -266,6 +276,7 @@ class ServiceWorkerCacheTest : public testing::Test {
   TestBrowserContext browser_context_;
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_;
+  scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   storage::BlobStorageContext* blob_storage_context_;
 
   base::ScopedTempDir temp_dir_;
@@ -530,6 +541,30 @@ TEST_F(ServiceWorkerCacheTest, CaselessServiceWorkerFetchRequestHeaders) {
   EXPECT_EQ("bar", request.headers["content-type"]);
 }
 
+TEST_P(ServiceWorkerCacheTestP, QuotaManagerModified) {
+  EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count());
+
+  EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+  EXPECT_EQ(1, quota_manager_proxy_->notify_storage_modified_count());
+  EXPECT_LT(0, quota_manager_proxy_->last_notified_delta());
+  int64 sum_delta = quota_manager_proxy_->last_notified_delta();
+
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_EQ(2, quota_manager_proxy_->notify_storage_modified_count());
+  EXPECT_LT(sum_delta, quota_manager_proxy_->last_notified_delta());
+  sum_delta += quota_manager_proxy_->last_notified_delta();
+
+  EXPECT_TRUE(Delete(body_request_));
+  EXPECT_EQ(3, quota_manager_proxy_->notify_storage_modified_count());
+  sum_delta += quota_manager_proxy_->last_notified_delta();
+
+  EXPECT_TRUE(Delete(no_body_request_));
+  EXPECT_EQ(4, quota_manager_proxy_->notify_storage_modified_count());
+  sum_delta += quota_manager_proxy_->last_notified_delta();
+
+  EXPECT_EQ(0, sum_delta);
+}
+
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));

content/browser/service_worker/service_worker_context_core.cc

@@ -23,6 +23,7 @@
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/public/browser/browser_thread.h"
+#include "storage/browser/quota/quota_manager_proxy.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -122,10 +123,10 @@ ServiceWorkerContextCore::ServiceWorkerContextCore(
                                             disk_cache_thread,
                                             quota_manager_proxy,
                                             special_storage_policy)),
-      cache_manager_(
-          ServiceWorkerCacheStorageManager::Create(path,
-                                                   cache_task_runner.get(),
-                                                   quota_manager_proxy)),
+      cache_manager_(ServiceWorkerCacheStorageManager::Create(
+          path,
+          cache_task_runner.get(),
+          make_scoped_refptr(quota_manager_proxy))),
       embedded_worker_registry_(EmbeddedWorkerRegistry::Create(AsWeakPtr())),
       job_coordinator_(new ServiceWorkerJobCoordinator(AsWeakPtr())),
       next_handle_id_(0),