webkit: Update the calls from RunAllPending() to RunUntilIdle().

webkit/appcache/mock_appcache_storage_unittest.cc

 // Copyright (c) 2012 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 "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_storage.h"
@@ skipping 66 matching lines @@
 };
 
 
 TEST_F(MockAppCacheStorageTest, LoadCache_Miss) {
   // Attempt to load a cache that doesn't exist. Should
   // complete asyncly.
   MockAppCacheService service;
   MockStorageDelegate delegate;
   service.storage()->LoadCache(111, &delegate);
   EXPECT_NE(111, delegate.loaded_cache_id_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(111, delegate.loaded_cache_id_);
   EXPECT_FALSE(delegate.loaded_cache_);
 }
 
 TEST_F(MockAppCacheStorageTest, LoadCache_NearHit) {
   // Attempt to load a cache that is currently in use
   // and does not require loading from disk. This
   // load should complete syncly.
   MockAppCacheService service;
 
@@ skipping 13 matching lines @@
   // Attempt to load/create a group that doesn't exist.
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
   MockStorageDelegate delegate;
   GURL manifest_url("http://blah/");
   service.storage()->LoadOrCreateGroup(manifest_url, &delegate);
   EXPECT_NE(manifest_url, delegate.loaded_manifest_url_);
   EXPECT_FALSE(delegate.loaded_group_.get());
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_);
   EXPECT_TRUE(delegate.loaded_group_.get());
   EXPECT_TRUE(delegate.loaded_group_->HasOneRef());
   EXPECT_FALSE(delegate.loaded_group_->newest_complete_cache());
   EXPECT_TRUE(storage->stored_groups_.empty());
 }
 
 TEST_F(MockAppCacheStorageTest, LoadGroup_NearHit) {
   // Attempt to load a group that is currently in use
   // and does not require loading from disk. This
   // load should complete syncly.
   MockAppCacheService service;
   MockStorageDelegate delegate;
 
   // Setup some preconditions. Create a group that appears
   // to be "unstored" and "currently in use".
   GURL manifest_url("http://blah/");
   service.storage()->LoadOrCreateGroup(manifest_url, &delegate);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_);
   EXPECT_TRUE(delegate.loaded_group_.get());
 
   // Reset our delegate, and take a reference to the new group.
   scoped_refptr<AppCacheGroup> group;
   group.swap(delegate.loaded_group_);
   delegate.loaded_manifest_url_ = GURL();
 
   // Conduct the test.
   service.storage()->LoadOrCreateGroup(manifest_url, &delegate);
@@ skipping 31 matching lines @@
 
   // Setup a delegate to receive completion callbacks.
   MockStorageDelegate delegate;
 
   // Conduct the cache load test.
   EXPECT_NE(cache_id, delegate.loaded_cache_id_);
   EXPECT_NE(cache_ptr, delegate.loaded_cache_.get());
   storage->LoadCache(cache_id, &delegate);
   EXPECT_NE(cache_id, delegate.loaded_cache_id_);
   EXPECT_NE(cache_ptr, delegate.loaded_cache_.get());
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(cache_id, delegate.loaded_cache_id_);
   EXPECT_EQ(cache_ptr, delegate.loaded_cache_.get());
   delegate.loaded_cache_ = NULL;
 
   // Conduct the group load test.
   EXPECT_NE(manifest_url, delegate.loaded_manifest_url_);
   EXPECT_FALSE(delegate.loaded_group_.get());
   storage->LoadOrCreateGroup(manifest_url, &delegate);
   EXPECT_NE(manifest_url, delegate.loaded_manifest_url_);
   EXPECT_FALSE(delegate.loaded_group_.get());
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(manifest_url, delegate.loaded_manifest_url_);
   EXPECT_EQ(group_ptr, delegate.loaded_group_.get());
 }
 
 TEST_F(MockAppCacheStorageTest, StoreNewGroup) {
   // Store a group and its newest cache. Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create a group and newest cache that
   // appears to be "unstored".
   GURL manifest_url("http://blah/");
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, manifest_url, 111));
   int64 cache_id = storage->NewCacheId();
   scoped_refptr<AppCache> cache(new AppCache(&service, cache_id));
   // Hold a ref to the cache simulate the UpdateJob holding that ref,
   // and hold a ref to the group to simulate the CacheHost holding that ref.
 
   // Conduct the store test.
   MockStorageDelegate delegate;
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
   storage->StoreGroupAndNewestCache(group, cache, &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.stored_group_success_);
   EXPECT_FALSE(storage->stored_caches_.empty());
   EXPECT_FALSE(storage->stored_groups_.empty());
   EXPECT_EQ(cache, group->newest_complete_cache());
   EXPECT_TRUE(cache->is_complete());
 }
 
 TEST_F(MockAppCacheStorageTest, StoreExistingGroup) {
   // Store a group and its newest cache. Should complete asyncly.
   MockAppCacheService service;
@@ skipping 20 matching lines @@
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_TRUE(storage->IsCacheStored(old_cache));
   EXPECT_FALSE(storage->IsCacheStored(new_cache));
   storage->StoreGroupAndNewestCache(group, new_cache, &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_TRUE(storage->IsCacheStored(old_cache));
   EXPECT_FALSE(storage->IsCacheStored(new_cache));
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_FALSE(storage->IsCacheStored(old_cache));
   EXPECT_TRUE(storage->IsCacheStored(new_cache));
   EXPECT_EQ(new_cache.get(), group->newest_complete_cache());
   EXPECT_TRUE(new_cache->is_complete());
 }
 
 TEST_F(MockAppCacheStorageTest, StoreExistingGroupExistingCache) {
@@ skipping 22 matching lines @@
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_TRUE(storage->IsCacheStored(cache));
   storage->StoreGroupAndNewestCache(group, cache, &delegate);
   EXPECT_FALSE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.stored_group_success_);
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_TRUE(storage->IsCacheStored(cache));
   EXPECT_EQ(cache, group->newest_complete_cache());
   EXPECT_TRUE(cache->GetEntry(entry_url));
 }
 
 TEST_F(MockAppCacheStorageTest, MakeGroupObsolete) {
   // Make a group obsolete, should complete asyncly.
@@ skipping 20 matching lines @@
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_FALSE(cache->HasOneRef());
   EXPECT_FALSE(group->HasOneRef());
   storage->MakeGroupObsolete(group, &delegate);
   EXPECT_FALSE(group->is_obsolete());
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_FALSE(cache->HasOneRef());
   EXPECT_FALSE(group->HasOneRef());
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_TRUE(delegate.obsoleted_success_);
   EXPECT_EQ(group.get(), delegate.obsoleted_group_.get());
   EXPECT_TRUE(group->is_obsolete());
   EXPECT_TRUE(storage->stored_caches_.empty());
   EXPECT_TRUE(storage->stored_groups_.empty());
   EXPECT_TRUE(cache->HasOneRef());
   EXPECT_FALSE(group->HasOneRef());
   delegate.obsoleted_group_ = NULL;
   cache = NULL;
   EXPECT_TRUE(group->HasOneRef());
@@ skipping 24 matching lines @@
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Conduct the test.
   MockStorageDelegate delegate;
   GURL url("http://blah/some_url");
   EXPECT_NE(url, delegate.found_url_);
   storage->FindResponseForMainRequest(url, GURL(), &delegate);
   EXPECT_NE(url, delegate.found_url_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(url, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
   EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
@@ skipping 16 matching lines @@
       new AppCacheGroup(&service, kManifestUrl, 111));
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_EQ(kManifestUrl, delegate.found_manifest_url_);
   EXPECT_EQ(kCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kResponseId, delegate.found_entry_.response_id());
   EXPECT_TRUE(delegate.found_entry_.IsExplicit());
   EXPECT_FALSE(delegate.found_fallback_entry_.has_response_id());
 }
 
 TEST_F(MockAppCacheStorageTest, BasicFindMainFallbackResponse) {
   // Should complete asyncly.
@@ skipping 36 matching lines @@
 
   // The test url is in both fallback namespace urls, but should match
   // the longer of the two.
   const GURL kTestUrl("http://blah/fallback_namespace/longer/test");
 
   // Conduct the test.
   MockStorageDelegate delegate;
   EXPECT_NE(kTestUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kTestUrl, GURL(), &delegate);
   EXPECT_NE(kTestUrl, delegate.found_url_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kTestUrl, delegate.found_url_);
   EXPECT_EQ(kManifestUrl, delegate.found_manifest_url_);
   EXPECT_EQ(kCacheId, delegate.found_cache_id_);
   EXPECT_FALSE(delegate.found_entry_.has_response_id());
   EXPECT_EQ(kResponseId2, delegate.found_fallback_entry_.response_id());
   EXPECT_EQ(kFallbackEntryUrl2, delegate.found_fallback_url_);
   EXPECT_TRUE(delegate.found_fallback_entry_.IsFallback());
 }
 
 TEST_F(MockAppCacheStorageTest, FindMainResponseWithMultipleCandidates) {
@@ skipping 36 matching lines @@
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   // Conduct the test, we should find the response from the second cache
   // since it's "in use".
   MockStorageDelegate delegate;
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_EQ(kManifestUrl2, delegate.found_manifest_url_);
   EXPECT_EQ(kCacheId2, delegate.found_cache_id_);
   EXPECT_EQ(kResponseId2, delegate.found_entry_.response_id());
   EXPECT_TRUE(delegate.found_entry_.IsExplicit());
   EXPECT_FALSE(delegate.found_fallback_entry_.has_response_id());
 }
 
 TEST_F(MockAppCacheStorageTest, FindMainResponseExclusions) {
   // Should complete asyncly.
@@ skipping 25 matching lines @@
   group->AddCache(cache);
   storage->AddStoredGroup(group);
   storage->AddStoredCache(cache);
 
   MockStorageDelegate delegate;
 
   // We should not find anything for the foreign entry.
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, GURL(), &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
   EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 
   // We should not find anything for the online namespace.
   EXPECT_NE(kOnlineNamespaceUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kOnlineNamespaceUrl, GURL(), &delegate);
   EXPECT_NE(kOnlineNamespaceUrl, delegate.found_url_);
-  MessageLoop::current()->RunAllPending();  // Do async task execution.
+  MessageLoop::current()->RunUntilIdle();  // Do async task execution.
   EXPECT_EQ(kOnlineNamespaceUrl, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
   EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 }  // namespace appcache