[CacheStorage] Prioritize Size operations over other scheduled operations

content/browser/cache_storage/cache_storage_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/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 445 matching lines @@
 }
 
 void CacheStorageCache::Size(const SizeCallback& callback) {
   if (!LazyInitialize()) {
     // TODO(jkarlin): Delete caches that can't be initialized.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, 0));
     return;
   }
 
-  // If the cache isn't already initialized, wait for it.
   if (initializing_) {
-    SizeCallback pending_callback =
-        base::Bind(&CacheStorageCache::PendingSizeCallback,
-                   weak_ptr_factory_.GetWeakPtr(), callback);
-    scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::SizeImpl,
-                                             weak_ptr_factory_.GetWeakPtr(),
-                                             pending_callback));
+    // Note that Size doesn't use the scheduler, see header comments for why.
+    pending_size_callbacks_.push_back(callback);
     return;
   }
 
   // Run immediately so that we don't deadlock on
   // CacheStorageCache::PutDidDelete's call to
   // quota_manager_proxy_->GetUsageAndQuota.
   SizeImpl(callback);
 }
 
 void CacheStorageCache::GetSizeThenClose(const SizeCallback& callback) {
@@ skipping 950 matching lines @@
 
 void CacheStorageCache::InitGotCacheSize(CacheStorageError cache_create_error,
                                          int cache_size) {
   cache_size_ = cache_size;
   initializing_ = false;
   backend_state_ = (cache_create_error == CACHE_STORAGE_OK && backend_ &&
                     backend_state_ == BACKEND_UNINITIALIZED)
                        ? BACKEND_OPEN
                        : BACKEND_CLOSED;
 
+  for (const SizeCallback& callback : pending_size_callbacks_)
+    SizeImpl(callback);
+  pending_size_callbacks_.clear();
+
   UMA_HISTOGRAM_ENUMERATION("ServiceWorkerCache.InitBackendResult",
                             cache_create_error, CACHE_STORAGE_ERROR_LAST + 1);
 
   scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorageCache::PendingClosure(const base::Closure& callback) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run();
@@ skipping 85 matching lines @@
   storage::BlobDataBuilder blob_data(response->blob_uuid);
 
   disk_cache::Entry* temp_entry = entry.get();
   blob_data.AppendDiskCacheEntryWithSideData(
       new CacheStorageCacheDataHandle(this, std::move(entry)), temp_entry,
       INDEX_RESPONSE_BODY, INDEX_SIDE_DATA);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 }  // namespace content