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

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 <utility>
 
@@ skipping 403 matching lines @@
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Close(base::Bind(&CacheStorageCacheTest::CloseCallback,
                              base::Unretained(this),
                              base::Unretained(loop.get())));
     loop->Run();
     return callback_closed_;
   }
 
   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;
     cache_->Size(base::Bind(&CacheStorageCacheTest::SizeCallback,
                             base::Unretained(this), &run_loop));
     run_loop.Run();
     return callback_size_;
   }
 
   void RequestsCallback(base::RunLoop* run_loop,
                         CacheStorageError error,
                         scoped_ptr<CacheStorageCache::Requests> requests) {
@@ skipping 493 matching lines @@
                                     false);
   request.headers["content-type"] = "foo";
   request.headers["Content-Type"] = "bar";
   EXPECT_EQ("bar", request.headers["content-type"]);
 }
 
 TEST_P(CacheStorageCacheTestP, QuotaManagerModified) {
   EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count());
 
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+  // Storage notification happens after the operation returns, so continue the
+  // event loop.
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, quota_manager_proxy_->notify_storage_modified_count());
   EXPECT_LT(0, quota_manager_proxy_->last_notified_delta());
   int64_t sum_delta = quota_manager_proxy_->last_notified_delta();
 
   EXPECT_TRUE(Put(body_request_, body_response_));
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(2, quota_manager_proxy_->notify_storage_modified_count());
   EXPECT_LT(sum_delta, quota_manager_proxy_->last_notified_delta());
   sum_delta += quota_manager_proxy_->last_notified_delta();
 
   EXPECT_TRUE(Delete(body_request_));
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3, quota_manager_proxy_->notify_storage_modified_count());
   sum_delta += quota_manager_proxy_->last_notified_delta();
 
   EXPECT_TRUE(Delete(no_body_request_));
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(4, quota_manager_proxy_->notify_storage_modified_count());
   sum_delta += quota_manager_proxy_->last_notified_delta();
 
   EXPECT_EQ(0, sum_delta);
 }
 
 TEST_P(CacheStorageCacheTestP, PutObeysQuotaLimits) {
   mock_quota_manager_->SetQuota(GURL(kOrigin), storage::kStorageTypeTemporary,
                                 0);
   EXPECT_FALSE(Put(no_body_request_, no_body_response_));
@@ skipping 74 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