Write out CacheStorageCache size to index file.

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 <memory>
@@ skipping 16 matching lines @@
 class IOBufferWithSize;
 }
 
 namespace storage {
 class BlobDataHandle;
 class BlobStorageContext;
 class QuotaManagerProxy;
 }
 
 namespace content {
+class CacheMetadata;
 class CacheStorage;
 class CacheStorageBlobToDiskCache;
 class CacheStorageCacheHandle;
-class CacheMetadata;
+class CacheStorageCacheObserver;
 class CacheStorageScheduler;
 class TestCacheStorageCache;
 
 // Represents a ServiceWorker Cache as seen in
 // https://slightlyoff.github.io/ServiceWorker/spec/service_worker/ The
 // asynchronous methods are executed serially. Callbacks to the public functions
 // will be called so long as the cache object lives.
 class CONTENT_EXPORT CacheStorageCache {
  public:
   using ErrorCallback = base::Callback<void(CacheStorageError)>;
@@ skipping 21 matching lines @@
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
   static std::unique_ptr<CacheStorageCache> CreatePersistentCache(
       const GURL& origin,
       const std::string& cache_name,
       CacheStorage* cache_storage,
       const base::FilePath& path,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
-      base::WeakPtr<storage::BlobStorageContext> blob_context);
+      base::WeakPtr<storage::BlobStorageContext> blob_context,
+      int64_t cache_size);
 
   // Returns ERROR_TYPE_NOT_FOUND if not found.
   void Match(std::unique_ptr<ServiceWorkerFetchRequest> request,
              const CacheStorageCacheQueryParams& match_params,
              const ResponseCallback& callback);
 
   // Returns CACHE_STORAGE_OK and matched responses in this cache. If there are
   // no responses, returns CACHE_STORAGE_OK and an empty vector.
   void MatchAll(std::unique_ptr<ServiceWorkerFetchRequest> request,
                 const CacheStorageCacheQueryParams& match_params,
@@ skipping 54 matching lines @@
   // the cache's size.
   void GetSizeThenClose(const SizeCallback& callback);
 
   // Async operations in progress will cancel and not run their callbacks.
   virtual ~CacheStorageCache();
 
   base::FilePath path() const { return path_; }
 
   std::string cache_name() const { return cache_name_; }
 
+  int64_t cache_size() const { return cache_size_; }
+
+  void SetObserver(CacheStorageCacheObserver* observer);

[jkarlin, 2016/10/21 18:04:19]

This needs documentation, especially to specify that SetObserver(nullptr) must
be called if the observer is deleted before the cache.

[cmumford, 2016/11/10 17:28:16]

Function deleted.

+
   base::WeakPtr<CacheStorageCache> AsWeakPtr();
 
  private:
   enum class QueryCacheType { REQUESTS, REQUESTS_AND_RESPONSES, CACHE_ENTRIES };
 
   // The backend progresses from uninitialized, to open, to closed, and cannot
   // reverse direction.  The open step may be skipped.
   enum BackendState {
     BACKEND_UNINITIALIZED,  // No backend, create backend on first operation.
     BACKEND_OPEN,           // Backend can be used.
@@ skipping 21 matching lines @@
       base::Callback<void(std::unique_ptr<OpenAllEntriesContext>,
                           CacheStorageError)>;
 
   CacheStorageCache(
       const GURL& origin,
       const std::string& cache_name,
       const base::FilePath& path,
       CacheStorage* cache_storage,
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
-      base::WeakPtr<storage::BlobStorageContext> blob_context);
+      base::WeakPtr<storage::BlobStorageContext> blob_context,
+      int64_t cache_size);
 
   // Returns all entries in this cache.
   void OpenAllEntries(const OpenAllEntriesCallback& callback);
   void DidOpenNextEntry(std::unique_ptr<OpenAllEntriesContext> entries_context,
                         const OpenAllEntriesCallback& callback,
                         int rv);
 
   // Runs |callback| with matching requests/response data. The data provided
   // in the QueryCacheResults depends on the |query_type|. If |query_type| is
   // CACHE_ENTRIES then only out_entries is valid. If |query_type| is REQUESTS
@@ skipping 168 matching lines @@
 
   // Raw pointer is safe because CacheStorage owns this object.
   CacheStorage* cache_storage_;
 
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
   BackendState backend_state_ = BACKEND_UNINITIALIZED;
   std::unique_ptr<CacheStorageScheduler> scheduler_;
   bool initializing_ = false;
-  int64_t cache_size_ = 0;
+  int64_t cache_size_;
   size_t max_query_size_bytes_;
+  CacheStorageCacheObserver* cache_observer_;
 
   // 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_