[CacheStorage] Use backend size to determine change in cache size in put and delete

content/browser/cache_storage/cache_storage_cache.h

 // 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.
 
 #ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 189 matching lines @@
                          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,
                               BlobToDiskCacheIDMap::KeyType blob_to_cache_key,
                               disk_cache::ScopedEntryPtr entry,
                               bool success);
 
+  // Asynchronously calculates the current cache size, notifies the quota
+  // manager of any change from the last report, and sets cache_size_ to the new
+  // size. Runs |callback| once complete.
+  void UpdateCacheSize();
+  void UpdateCacheSizeGotSize(int current_cache_size);
+
   // Returns ERROR_NOT_FOUND if not found. Otherwise deletes and returns OK.
   void Delete(const CacheStorageBatchOperation& operation,
               const ErrorCallback& callback);
   void DeleteImpl(scoped_ptr<ServiceWorkerFetchRequest> request,
                   const ErrorCallback& callback);
-  void DeleteDidOpenEntry(
-      const GURL& origin,
-      scoped_ptr<ServiceWorkerFetchRequest> request,
-      const CacheStorageCache::ErrorCallback& callback,
-      scoped_ptr<disk_cache::Entry*> entryptr,
-      const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
-      int rv);
+  void DeleteDidOpenEntry(const GURL& origin,
+                          scoped_ptr<ServiceWorkerFetchRequest> request,
+                          const CacheStorageCache::ErrorCallback& callback,
+                          scoped_ptr<disk_cache::Entry*> entryptr,
+                          int rv);
 
   // Keys callbacks.
   void KeysImpl(const RequestsCallback& callback);
   void KeysDidOpenAllEntries(const RequestsCallback& callback,
                              scoped_ptr<OpenAllEntriesContext> entries_context,
                              CacheStorageError error);
   void KeysProcessNextEntry(scoped_ptr<KeysContext> keys_context,
                             const Entries::iterator& iter);
   void KeysDidReadMetadata(scoped_ptr<KeysContext> keys_context,
                            const Entries::iterator& iter,
                            scoped_ptr<CacheMetadata> metadata);
 
   void CloseImpl(const base::Closure& callback);
 
   void SizeImpl(const SizeCallback& callback);
 
   // Loads the backend and calls the callback with the result (true for
   // success). The callback will always be called. Virtual for tests.
   virtual void CreateBackend(const ErrorCallback& callback);
   void CreateBackendDidCreate(const CacheStorageCache::ErrorCallback& callback,
                               scoped_ptr<ScopedBackendPtr> backend_ptr,
                               int rv);
 
   void InitBackend();
-  void InitDone(CacheStorageError error);
+  void InitDidCreateBackend(CacheStorageError cache_create_error);
+  void InitGotCacheSize(CacheStorageError cache_create_error, int cache_size);
 
   void PendingClosure(const base::Closure& callback);
   void PendingErrorCallback(const ErrorCallback& callback,
                             CacheStorageError error);
   void PendingResponseCallback(
       const ResponseCallback& callback,
       CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle);
   void PendingResponsesCallback(const ResponsesCallback& callback,
@@ skipping 12 matching lines @@
       ServiceWorkerResponse* response);
 
   // Be sure to check |backend_state_| before use.
   scoped_ptr<disk_cache::Backend> backend_;
 
   GURL origin_;
   base::FilePath path_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
-  BackendState backend_state_;
+  BackendState backend_state_ = BACKEND_UNINITIALIZED;
   scoped_ptr<CacheStorageScheduler> scheduler_;
-  bool initializing_;
+  bool initializing_ = false;
+  int64_t cache_size_ = 0;
 
   // Owns the elements of the list
   BlobToDiskCacheIDMap active_blob_to_disk_cache_writers_;
 
   // Whether or not to store data in disk or memory.
   bool memory_only_;
 
   base::WeakPtrFactory<CacheStorageCache> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageCache);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_H_