[ServiceWorkerCache] Call QuotaManager::NotifyStorageModified from Cache.

content/browser/service_worker/service_worker_cache.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.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context.h"
 #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 "third_party/WebKit/public/platform/WebServiceWorkerResponseType.h"
 
 namespace content {
 
 namespace {
 
 typedef scoped_ptr<disk_cache::Backend> ScopedBackendPtr;
 typedef base::Callback<void(bool)> BoolCallback;
 typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
     EntryBoolCallback;
@@ skipping 54 matching lines @@
   scoped_refptr<net::IOBufferWithSize> buffer;
   scoped_refptr<storage::BlobData> blob_data;
   int total_bytes_read;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseReadContext);
 };
 
 // Streams data from a blob and writes it to a given disk_cache::Entry.
 class BlobReader : public net::URLRequest::Delegate {
  public:
-  typedef base::Callback<void(bool)> BoolCallback;
+  typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
+      EntryAndBoolCallback;
 
-  BlobReader(disk_cache::ScopedEntryPtr entry)
+  BlobReader()
       : cache_entry_offset_(0),
         buffer_(new net::IOBufferWithSize(kBufferSize)),
-        weak_ptr_factory_(this) {
+        weak_ptr_factory_(this) {}
+
+  // |entry| is passed to the callback once complete.
+  void StreamBlobToCache(disk_cache::ScopedEntryPtr entry,
+                         net::URLRequestContext* request_context,
+                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+                         const EntryAndBoolCallback& callback) {
     DCHECK(entry);
     entry_ = entry.Pass();
-  }
-
-  void StreamBlobToCache(net::URLRequestContext* request_context,
-                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                         const BoolCallback& callback) {
     callback_ = callback;
     blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
         blob_data_handle.Pass(), request_context, this);
     blob_request_->Start();
   }
 
   // net::URLRequest::Delegate overrides for reading blobs.
   void OnReceivedRedirect(net::URLRequest* request,
                           const net::RedirectInfo& redirect_info,
                           bool* defer_redirect) override {
@@ skipping 12 matching lines @@
                              const net::SSLInfo& ssl_info,
                              bool fatal) override {
     NOTREACHED();
   }
   void OnBeforeNetworkStart(net::URLRequest* request, bool* defer) override {
     NOTREACHED();
   }
 
   void OnResponseStarted(net::URLRequest* request) override {
     if (!request->status().is_success()) {
-      callback_.Run(false);
+      callback_.Run(entry_.Pass(), false);
       return;
     }
     ReadFromBlob();
   }
 
   virtual void ReadFromBlob() {
     int bytes_read = 0;
     bool done =
         blob_request_->Read(buffer_.get(), buffer_->size(), &bytes_read);
     if (done)
       OnReadCompleted(blob_request_.get(), bytes_read);
   }
 
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override {
     if (!request->status().is_success()) {
-      callback_.Run(false);
+      callback_.Run(entry_.Pass(), false);
       return;
     }
 
     if (bytes_read == 0) {
-      callback_.Run(true);
+      callback_.Run(entry_.Pass(), true);
       return;
     }
 
     net::CompletionCallback cache_write_callback =
         base::Bind(&BlobReader::DidWriteDataToEntry,
                    weak_ptr_factory_.GetWeakPtr(),
                    bytes_read);
 
     int rv = entry_->WriteData(INDEX_RESPONSE_BODY,
                                cache_entry_offset_,
                                buffer_.get(),
                                bytes_read,
                                cache_write_callback,
                                true /* truncate */);
     if (rv != net::ERR_IO_PENDING)
       cache_write_callback.Run(rv);
   }
 
   void DidWriteDataToEntry(int expected_bytes, int rv) {
     if (rv != expected_bytes) {
-      callback_.Run(false);
+      callback_.Run(entry_.Pass(), false);
       return;
     }
 
     cache_entry_offset_ += rv;
     ReadFromBlob();
   }
 
  private:
   int cache_entry_offset_;
   disk_cache::ScopedEntryPtr entry_;
   scoped_ptr<net::URLRequest> blob_request_;
-  BoolCallback callback_;
+  EntryAndBoolCallback callback_;
   scoped_refptr<net::IOBufferWithSize> buffer_;
   base::WeakPtrFactory<BlobReader> weak_ptr_factory_;
 };
 
 // The state needed to pass between ServiceWorkerCache::Put callbacks.
 struct PutContext {
-  PutContext(scoped_ptr<ServiceWorkerFetchRequest> request,
-             scoped_ptr<ServiceWorkerResponse> response,
-             scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-             const ServiceWorkerCache::ResponseCallback& callback,
-             net::URLRequestContext* request_context)
-      : request(request.Pass()),
+  PutContext(
+      const GURL& origin,
+      scoped_ptr<ServiceWorkerFetchRequest> request,
+      scoped_ptr<ServiceWorkerResponse> response,
+      scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+      const ServiceWorkerCache::ResponseCallback& callback,
+      net::URLRequestContext* request_context,
+      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
+      : origin(origin),
+        request(request.Pass()),
         response(response.Pass()),
         blob_data_handle(blob_data_handle.Pass()),
         callback(callback),
         request_context(request_context),
+        quota_manager_proxy(quota_manager_proxy),
         cache_entry(NULL) {}
   ~PutContext() {
     if (cache_entry)
       cache_entry->Close();
   }
 
   // Input parameters to the Put function.
+  GURL origin;
   scoped_ptr<ServiceWorkerFetchRequest> request;
   scoped_ptr<ServiceWorkerResponse> response;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
   ServiceWorkerCache::ResponseCallback callback;
-
   net::URLRequestContext* request_context;
+  scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy;
 
   // This isn't a scoped_ptr because the disk_cache needs an Entry** as input to
   // CreateEntry.
   disk_cache::Entry* cache_entry;
 
   // The BlobDataHandle for the output ServiceWorkerResponse.
   scoped_ptr<storage::BlobDataHandle> out_blob_data_handle;
 
   DISALLOW_COPY_AND_ASSIGN(PutContext);
 };
 
 // Put callbacks
 void PutDidCreateEntry(scoped_ptr<PutContext> put_context, int rv);
 void PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
                         int expected_bytes,
                         int rv);
 void PutDidWriteBlobToCache(scoped_ptr<PutContext> put_context,
                             scoped_ptr<BlobReader> blob_reader,
+                            disk_cache::ScopedEntryPtr entry,
                             bool success);
 
 // Match callbacks
 void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv);
 void MatchDidReadHeaderData(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
 void MatchDidReadResponseBodyData(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<ResponseReadContext> response_context,
     int rv);
 void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
                        scoped_ptr<ResponseReadContext> response_context);
 
 // Delete callbacks
-void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
-                        const ServiceWorkerCache::ErrorCallback& callback,
-                        scoped_ptr<disk_cache::Entry*> entryptr,
-                        int rv);
+void DeleteDidOpenEntry(
+    const GURL& origin,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    const ServiceWorkerCache::ErrorCallback& callback,
+    scoped_ptr<disk_cache::Entry*> entryptr,
+    const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
+    int rv);
 
 // Copy headers out of a cache entry and into a protobuf. The callback is
 // guaranteed to be run.
 void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback);
 void ReadHeadersDidReadHeaderData(
     disk_cache::Entry* entry,
     const HeadersCallback& callback,
     const scoped_refptr<net::IOBufferWithSize>& buffer,
     int rv);
 
@@ skipping 75 matching lines @@
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
                               scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
   if (put_context->response->blob_uuid.empty()) {
+    if (put_context->quota_manager_proxy.get()) {
+      put_context->quota_manager_proxy->NotifyStorageModified(
+          storage::QuotaClient::kServiceWorkerCache,
+          put_context->origin,
+          storage::kStorageTypeTemporary,
+          put_context->cache_entry->GetDataSize(INDEX_HEADERS));
+    }
+
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK,
                               put_context->response.Pass(),
                               scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   DCHECK(put_context->blob_data_handle);
 
   disk_cache::ScopedEntryPtr entry(put_context->cache_entry);
   put_context->cache_entry = NULL;
-  scoped_ptr<BlobReader> reader(new BlobReader(entry.Pass()));
-
+  scoped_ptr<BlobReader> reader(new BlobReader());
   BlobReader* reader_ptr = reader.get();
 
   // Grab some pointers before passing put_context in Bind.
   net::URLRequestContext* request_context = put_context->request_context;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle =
       put_context->blob_data_handle.Pass();
 
-  reader_ptr->StreamBlobToCache(request_context,
+  reader_ptr->StreamBlobToCache(entry.Pass(),
+                                request_context,
                                 blob_data_handle.Pass(),
                                 base::Bind(PutDidWriteBlobToCache,
                                            base::Passed(put_context.Pass()),
                                            base::Passed(reader.Pass())));
 }
 
 void PutDidWriteBlobToCache(scoped_ptr<PutContext> put_context,
                             scoped_ptr<BlobReader> blob_reader,
+                            disk_cache::ScopedEntryPtr entry,
                             bool success) {
+  DCHECK(entry);
+  put_context->cache_entry = entry.release();
+
   if (!success) {
     put_context->cache_entry->Doom();
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
                               scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
+  if (put_context->quota_manager_proxy.get()) {
+    put_context->quota_manager_proxy->NotifyStorageModified(
+        storage::QuotaClient::kServiceWorkerCache,
+        put_context->origin,
+        storage::kStorageTypeTemporary,
+        put_context->cache_entry->GetDataSize(INDEX_HEADERS) +
+            put_context->cache_entry->GetDataSize(INDEX_RESPONSE_BODY));
+  }
+
   put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK,
                             put_context->response.Pass(),
                             put_context->out_blob_data_handle.Pass());
 }
 
 void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv) {
@@ skipping 214 matching lines @@
   }
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
       blob_storage->AddFinishedBlob(response_context->blob_data.get()));
 
   callback.Run(ServiceWorkerCache::ErrorTypeOK,
                response.Pass(),
                blob_data_handle.Pass());
 }
 
-void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
-                        const ServiceWorkerCache::ErrorCallback& callback,
-                        scoped_ptr<disk_cache::Entry*> entryptr,
-                        int rv) {
+void DeleteDidOpenEntry(
+    const GURL& origin,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    const ServiceWorkerCache::ErrorCallback& callback,
+    scoped_ptr<disk_cache::Entry*> entryptr,
+    const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
+    int rv) {
   if (rv != net::OK) {
     callback.Run(ServiceWorkerCache::ErrorTypeNotFound);
     return;
   }
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
 
+  if (quota_manager_proxy.get()) {
+    quota_manager_proxy->NotifyStorageModified(
+        storage::QuotaClient::kServiceWorkerCache,
+        origin,
+        storage::kStorageTypeTemporary,
+        -1 * (entry->GetDataSize(INDEX_HEADERS) +
+              entry->GetDataSize(INDEX_RESPONSE_BODY)));
+  }
+
   entry->Doom();
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
 void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback) {
   DCHECK(entry);
 
   scoped_refptr<net::IOBufferWithSize> buffer(
       new net::IOBufferWithSize(entry->GetDataSize(INDEX_HEADERS)));
 
@@ skipping 73 matching lines @@
 
   // Used for enumerating cache entries.
   scoped_ptr<disk_cache::Backend::Iterator> backend_iterator;
   disk_cache::Entry* enumerated_entry;
 
   DISALLOW_COPY_AND_ASSIGN(KeysContext);
 };
 
 // static
 scoped_refptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
+    const GURL& origin,
     net::URLRequestContext* request_context,
+    const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
-  return make_scoped_refptr(
-      new ServiceWorkerCache(base::FilePath(), request_context, blob_context));
+  return make_scoped_refptr(new ServiceWorkerCache(origin,
+                                                   base::FilePath(),
+                                                   request_context,
+                                                   quota_manager_proxy,
+                                                   blob_context));
 }
 
 // static
 scoped_refptr<ServiceWorkerCache> 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) {
-  return make_scoped_refptr(
-      new ServiceWorkerCache(path, request_context, blob_context));
+  return make_scoped_refptr(new ServiceWorkerCache(
+      origin, path, request_context, quota_manager_proxy, blob_context));
 }
 
 ServiceWorkerCache::~ServiceWorkerCache() {
 }
 
 base::WeakPtr<ServiceWorkerCache> ServiceWorkerCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
@@ skipping 83 matching lines @@
   }
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
   net::CompletionCallback open_entry_callback =
       base::Bind(DeleteDidOpenEntry,
+                 origin_,
                  base::Passed(request.Pass()),
                  callback,
-                 base::Passed(entry.Pass()));
+                 base::Passed(entry.Pass()),
+                 quota_manager_proxy_);
 
   int rv = backend_->OpenEntry(
       request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
   if (!initialized_) {
     Init(base::Bind(
@@ skipping 29 matching lines @@
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Close() {
   backend_.reset();
 }
 
 ServiceWorkerCache::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)
-    : path_(path),
+    : origin_(origin),
+      path_(path),
       request_context_(request_context),
+      quota_manager_proxy_(quota_manager_proxy),
       blob_storage_context_(blob_context),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
 
 void ServiceWorkerCache::PutImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle,
     const ResponseCallback& callback) {
   if (!backend_) {
     callback.Run(ErrorTypeStorage,
                  scoped_ptr<ServiceWorkerResponse>(),
                  scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  scoped_ptr<PutContext> put_context(new PutContext(request.Pass(),
+  scoped_ptr<PutContext> put_context(new PutContext(origin_,
+                                                    request.Pass(),
                                                     response.Pass(),
                                                     blob_data_handle.Pass(),
                                                     callback,
-                                                    request_context_));
+                                                    request_context_,
+                                                    quota_manager_proxy_));
 
   if (put_context->blob_data_handle) {
     // Grab another handle to the blob for the callback response.
     put_context->out_blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(
             put_context->response->blob_uuid);
   }
 
   disk_cache::Entry** entry_ptr = &put_context->cache_entry;
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
@@ skipping 145 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content