[CacheStorage] Prioritize Size operations over other scheduled operations

content/browser/cache_storage/cache_storage_cache_unittest.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 <stdint.h>
 
 #include <memory>
@@ skipping 510 matching lines @@
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   int64_t Size() {
     // Storage notification happens after an operation completes. Let the any
     // notifications complete before calling Size.
     base::RunLoop().RunUntilIdle();
 
     base::RunLoop run_loop;
+    bool callback_called = false;
     cache_->Size(base::Bind(&CacheStorageCacheTest::SizeCallback,
-                            base::Unretained(this), &run_loop));
+                            base::Unretained(this), &run_loop,
+                            &callback_called));
     run_loop.Run();
+    EXPECT_TRUE(callback_called);
     return callback_size_;
   }
 
   int64_t GetSizeThenClose() {
     base::RunLoop run_loop;
+    bool callback_called = false;
     cache_->GetSizeThenClose(base::Bind(&CacheStorageCacheTest::SizeCallback,
-                                        base::Unretained(this), &run_loop));
+                                        base::Unretained(this), &run_loop,
+                                        &callback_called));
     run_loop.Run();
+    EXPECT_TRUE(callback_called);
     return callback_size_;
   }
 
   void RequestsCallback(base::RunLoop* run_loop,
                         CacheStorageError error,
                         std::unique_ptr<CacheStorageCache::Requests> requests) {
     callback_error_ = error;
     callback_strings_.clear();
     if (requests) {
       for (size_t i = 0u; i < requests->size(); ++i)
@@ skipping 47 matching lines @@
     quit_closure.Run();
   }
 
   void CloseCallback(base::RunLoop* run_loop) {
     EXPECT_FALSE(callback_closed_);
     callback_closed_ = true;
     if (run_loop)
       run_loop->Quit();
   }
 
-  void SizeCallback(base::RunLoop* run_loop, int64_t size) {
+  void SizeCallback(base::RunLoop* run_loop,
+                    bool* callback_called,
+                    int64_t size) {
+    *callback_called = true;
     callback_size_ = size;
     if (run_loop)
       run_loop->Quit();
   }
 
   bool VerifyKeys(const std::vector<std::string>& expected_keys) {
     if (expected_keys.size() != callback_strings_.size())
       return false;
 
     std::set<std::string> found_set;
@@ skipping 663 matching lines @@
   EXPECT_TRUE(Delete(no_body_request_));
   EXPECT_EQ(0, Size());
 
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_LT(no_body_size, Size());
 
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_EQ(0, Size());
 }
 
+TEST_P(CacheStorageCacheTestP, SizeOperationsArePrioritized) {
+  // Test that pending size operations (those waiting for initialization) run
+  // before other scheduler operations.
+  cache_->set_delay_backend_creation(true);  // Delay cache initialization
+
+  CacheStorageBatchOperation operation;
+  operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
+  operation.request = body_request_;
+  operation.response = body_response_;
+
+  callback_error_ = CACHE_STORAGE_ERROR_NOT_FOUND;
+  base::RunLoop run_loop;
+  // Start a put operation that blocks on initialization.
+  cache_->BatchOperation(std::vector<CacheStorageBatchOperation>(1, operation),
+                         base::Bind(&CacheStorageCacheTest::ErrorTypeCallback,
+                                    base::Unretained(this), &run_loop));
+
+  // Next start a size operation that also blocks on initialization.
+  bool size_callback_called = false;
+  cache_->Size(base::Bind(&CacheStorageCacheTest::SizeCallback,
+                          base::Unretained(this), nullptr,
+                          &size_callback_called));
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(size_callback_called);
+  EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
+
+  // Finish initialization. The Size operation should complete before Put gets
+  // to run as Size has priority. See crbug.com/605663.
+  cache_->ContinueCreateBackend();
+  run_loop.Run();
+  EXPECT_TRUE(size_callback_called);
+  EXPECT_EQ(CACHE_STORAGE_OK, callback_error_);
+}
+
 TEST_P(CacheStorageCacheTestP, GetSizeThenClose) {
   EXPECT_TRUE(Put(body_request_, body_response_));
   int64_t cache_size = Size();
   EXPECT_EQ(cache_size, GetSizeThenClose());
   VerifyAllOpsFail();
 }
 
 TEST_P(CacheStorageCacheTestP, OpsFailOnClosedBackendNeverCreated) {
   cache_->set_delay_backend_creation(
       true);  // Will hang the test if a backend is created.
@@ skipping 52 matching lines @@
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content