[CacheStorage] Don't call GetUsageAndQuota from a scheduled operation

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 23 matching lines @@
 
 namespace content {
 
 class CacheStorageBlobToDiskCache;
 class CacheMetadata;
 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 (except for Size). Callbacks to
-// the public functions will be called so long as the cache object lives.
+// 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 base::RefCounted<CacheStorageCache> {
  public:
   using ErrorCallback = base::Callback<void(CacheStorageError)>;
   using ResponseCallback =
       base::Callback<void(CacheStorageError,
                           std::unique_ptr<ServiceWorkerResponse>,
                           std::unique_ptr<storage::BlobDataHandle>)>;
   using Responses = std::vector<ServiceWorkerResponse>;
   using BlobDataHandles = std::vector<storage::BlobDataHandle>;
@@ skipping 52 matching lines @@
   //
   // In the case of the PUT operation, puts request and response objects in the
   // cache and returns OK when all operations are successfully completed.
   // In the case of the DELETE operation, returns ERROR_NOT_FOUND if a specified
   // entry is not found. Otherwise deletes it and returns OK.
   //
   // TODO(nhiroki): This function should run all operations atomically.
   // http://crbug.com/486637
   void BatchOperation(const std::vector<CacheStorageBatchOperation>& operations,
                       const ErrorCallback& callback);
+  void BatchDidGetUsageAndQuota(
+      const std::vector<CacheStorageBatchOperation>& operations,
+      const ErrorCallback& callback,
+      int64_t space_required,
+      storage::QuotaStatusCode status_code,
+      int64_t usage,
+      int64_t quota);
   void BatchDidOneOperation(const base::Closure& barrier_closure,
                             ErrorCallback* callback,
                             CacheStorageError error);
   void BatchDidAllOperations(std::unique_ptr<ErrorCallback> callback);
 
   // TODO(jkarlin): Have keys take an optional ServiceWorkerFetchRequest.
   // Returns CACHE_STORAGE_OK and a vector of requests if there are no errors.
   void Keys(const RequestsCallback& callback);
 
   // Closes the backend. Future operations that require the backend
   // will exit early. Close should only be called once per CacheStorageCache.
   void Close(const base::Closure& callback);
 
-  // The size of the cache's contents. This runs in parallel with other Cache
-  // operations. This is because QuotaManager is a dependency of the Put
-  // operation and QuotaManager calls Size. If the cache isn't yet initialized,
-  // runs immediately after initialization, before any pending operations in the
-  // scheduler are run.
+  // The size of the cache's contents.
   void Size(const SizeCallback& callback);
 
   // Gets the cache's size, closes the backend, and then runs |callback| with
   // the cache's size.
   void GetSizeThenClose(const SizeCallback& callback);
 
   base::FilePath path() const { return path_; }
 
   base::WeakPtr<CacheStorageCache> AsWeakPtr();
 
@@ skipping 60 matching lines @@
       std::unique_ptr<MatchAllContext> context,
       std::unique_ptr<OpenAllEntriesContext> entries_context,
       CacheStorageError error);
   void MatchAllProcessNextEntry(std::unique_ptr<MatchAllContext> context,
                                 const Entries::iterator& iter);
   void MatchAllDidReadMetadata(std::unique_ptr<MatchAllContext> context,
                                const Entries::iterator& iter,
                                std::unique_ptr<CacheMetadata> metadata);
 
   // WriteSideData callbacks
+  void WriteSideDataDidGetQuota(const ErrorCallback& callback,
+                                const GURL& url,
+                                base::Time expected_response_time,
+                                scoped_refptr<net::IOBuffer> buffer,
+                                int buf_len,
+                                storage::QuotaStatusCode status_code,
+                                int64_t usage,
+                                int64_t quota);
+
   void WriteSideDataImpl(const ErrorCallback& callback,
                          const GURL& url,
                          base::Time expected_response_time,
                          scoped_refptr<net::IOBuffer> buffer,
                          int buf_len);
   void WriteSideDataDidGetUsageAndQuota(const ErrorCallback& callback,
                                         const GURL& url,
                                         base::Time expected_response_time,
                                         scoped_refptr<net::IOBuffer> buffer,
                                         int buf_len,
@@ skipping 121 matching lines @@
   std::unique_ptr<disk_cache::Backend> backend_;
 
   GURL origin_;
   const std::string cache_name_;
   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_ = BACKEND_UNINITIALIZED;
   std::unique_ptr<CacheStorageScheduler> scheduler_;
-  std::vector<SizeCallback> pending_size_callbacks_;
   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_