Convert CookieMonster tests to use base::RunLoop

net/cookies/cookie_monster_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 "net/cookies/cookie_store_unittest.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 97 matching lines @@
                               MultiThreadedCookieStoreTest,
                               CookieMonsterTestTraits);
 
 INSTANTIATE_TYPED_TEST_CASE_P(CookieMonsterStrictSecure,
                               CookieStoreTest,
                               CookieMonsterEnforcingStrictSecure);
 
 template <typename T>
 class CookieMonsterTestBase : public CookieStoreTest<T> {
  public:
-  using CookieStoreTest<T>::RunFor;
   using CookieStoreTest<T>::SetCookie;
 
  protected:
   using CookieStoreTest<T>::http_www_google_;
   using CookieStoreTest<T>::https_www_google_;
 
   CookieList GetAllCookiesForURL(CookieMonster* cm, const GURL& url) {
     DCHECK(cm);
     GetCookieListCallback callback;
     cm->GetAllCookiesForURLAsync(url, base::Bind(&GetCookieListCallback::Run,
                                                  base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.cookies();
   }
 
   CookieList GetAllCookiesForURLWithOptions(CookieMonster* cm,
                                             const GURL& url,
                                             const CookieOptions& options) {
     DCHECK(cm);
     GetCookieListCallback callback;
     cm->GetAllCookiesForURLWithOptionsAsync(
         url, options,
         base::Bind(&GetCookieListCallback::Run, base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.cookies();
   }
 
   bool SetCookieWithDetails(CookieMonster* cm,
                             const GURL& url,
                             const std::string& name,
                             const std::string& value,
                             const std::string& domain,
                             const std::string& path,
                             const base::Time& expiration_time,
                             bool secure,
                             bool http_only,
                             bool first_party_only,
                             CookiePriority priority) {
     DCHECK(cm);
     ResultSavingCookieCallback<bool> callback;
     cm->SetCookieWithDetailsAsync(
         url, name, value, domain, path, expiration_time, secure, http_only,
         first_party_only, false /* enforce prefixes */,
         false /* enforces strict secure cookies */, priority,
         base::Bind(&ResultSavingCookieCallback<bool>::Run,
                    base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   bool SetAllCookies(CookieMonster* cm, const CookieList& list) {
     DCHECK(cm);
     ResultSavingCookieCallback<bool> callback;
     cm->SetAllCookiesAsync(list,
                            base::Bind(&ResultSavingCookieCallback<bool>::Run,
                                       base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   int DeleteAll(CookieMonster* cm) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllAsync(base::Bind(&ResultSavingCookieCallback<int>::Run,
                                   base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   int DeleteAllCreatedBetween(CookieMonster* cm,
                               const base::Time& delete_begin,
                               const base::Time& delete_end) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
         base::Bind(&ResultSavingCookieCallback<int>::Run,
                    base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   int DeleteAllCreatedBetweenForHost(CookieMonster* cm,
                                      const base::Time delete_begin,
                                      const base::Time delete_end,
                                      const GURL& url) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
         base::Bind(&ResultSavingCookieCallback<int>::Run,
                    base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   int DeleteAllForHost(CookieMonster* cm, const GURL& url) {
     DCHECK(cm);
     ResultSavingCookieCallback<int> callback;
     cm->DeleteAllForHostAsync(url,
                               base::Bind(&ResultSavingCookieCallback<int>::Run,
                                          base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   bool DeleteCanonicalCookie(CookieMonster* cm, const CanonicalCookie& cookie) {
     DCHECK(cm);
     ResultSavingCookieCallback<bool> callback;
     cm->DeleteCanonicalCookieAsync(
         cookie, base::Bind(&ResultSavingCookieCallback<bool>::Run,
                            base::Unretained(&callback)));
-    RunFor(kTimeout);
-    EXPECT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     return callback.result();
   }
 
   // Helper for DeleteAllForHost test; repopulates CM with same layout
   // each time.
   void PopulateCmForDeleteAllForHost(scoped_refptr<CookieMonster> cm) {
     GURL url_top_level_domain_plus_1(kTopLevelDomainPlus1);
     GURL url_top_level_domain_plus_2(kTopLevelDomainPlus2);
     GURL url_top_level_domain_plus_2_secure(kTopLevelDomainPlus2Secure);
     GURL url_top_level_domain_plus_3(kTopLevelDomainPlus3);
@@ skipping 447 matching lines @@
   const std::string value;
   const std::string domain;
   const std::string path;
   const base::Time expiration_time;
   bool secure;
   bool http_only;
   bool first_party_only;
   CookiePriority priority;
 };
 
-ACTION(QuitCurrentMessageLoop) {
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
+ACTION_P(QuitRunLoop, run_loop) {
+  run_loop->Quit();
 }
 
 // TODO(erikwright): When the synchronous helpers 'GetCookies' etc. are removed,
 // rename these, removing the 'Action' suffix.
 ACTION_P4(DeleteCookieAction, cookie_monster, url, name, callback) {
   cookie_monster->DeleteCookieAsync(url, name, callback->AsCallback());
 }
 ACTION_P3(GetCookiesAction, cookie_monster, url, callback) {
   cookie_monster->GetCookiesWithOptionsAsync(url, CookieOptions(),
                                              callback->AsCallback());
@@ skipping 58 matching lines @@
 
 // This test suite verifies the task deferral behaviour of the CookieMonster.
 // Specifically, for each asynchronous method, verify that:
 // 1. invoking it on an uninitialized cookie store causes the store to begin
 //    chain-loading its backing data or loading data for a specific domain key
 //    (eTLD+1).
 // 2. The initial invocation does not complete until the loading completes.
 // 3. Invocations after the loading has completed complete immediately.
 class DeferredCookieTaskTest : public CookieMonsterTest {
  protected:
-  DeferredCookieTaskTest() {
+  DeferredCookieTaskTest() : expect_load_called_(false) {
     persistent_store_ = new NewMockPersistentCookieStore();
     cookie_monster_ = new CookieMonster(persistent_store_.get(), NULL);
   }
 
   // Defines a cookie to be returned from PersistentCookieStore::Load
   void DeclareLoadedCookie(const std::string& key,
                            const std::string& cookie_line,
                            const base::Time& creation_time) {
     AddCookieToList(key, cookie_line, creation_time, &loaded_cookies_);
   }
 
   // Runs the message loop, waiting until PersistentCookieStore::Load is called.
-  // Call CompleteLoadingAndWait to cause the load to complete.
+  // Call CompleteLoading to cause the load to complete.
   void WaitForLoadCall() {
-    RunFor(kTimeout);
+    load_run_loop_.Run();
 
     // Verify that PeristentStore::Load was called.
     testing::Mock::VerifyAndClear(persistent_store_.get());
   }
 
   // Invokes the PersistentCookieStore::LoadCookiesForKey completion callbacks
-  // and PersistentCookieStore::Load completion callback and waits
-  // until the message loop is quit.
-  void CompleteLoadingAndWait() {
+  // and PersistentCookieStore::Load completion callback.
+  void CompleteLoading() {
     while (!loaded_for_key_callbacks_.empty()) {
       loaded_for_key_callbacks_.front().Run(loaded_cookies_);
       loaded_cookies_.clear();
       loaded_for_key_callbacks_.pop();
     }
-
     loaded_callback_.Run(loaded_cookies_);
-    RunFor(kTimeout);
   }
 
   // Performs the provided action, expecting it to cause a call to
   // PersistentCookieStore::Load. Call WaitForLoadCall to verify the load call
   // is received.
   void BeginWith(testing::Action<void(void)> action) {
     EXPECT_CALL(*this, Begin()).WillOnce(action);
     ExpectLoadCall();
     Begin();
   }
 
   void BeginWithForDomainKey(std::string key,
                              testing::Action<void(void)> action) {
     EXPECT_CALL(*this, Begin()).WillOnce(action);
     ExpectLoadCall();
-    ExpectLoadForKeyCall(key, false);
+    ExpectLoadForKeyCall(key);
     Begin();
   }
 
   // Declares an expectation that PersistentCookieStore::Load will be called,
-  // saving the provided callback and sending a quit to the message loop.
+  // saving the provided callback and sending a quit to |load_run_loop_|.
   void ExpectLoadCall() {
+    // Make sure the |load_run_loop_| is not reused.
+    CHECK(!expect_load_called_);
+    expect_load_called_ = true;
     EXPECT_CALL(*persistent_store_.get(), Load(testing::_))
         .WillOnce(testing::DoAll(testing::SaveArg<0>(&loaded_callback_),
-                                 QuitCurrentMessageLoop()));
+                                 QuitRunLoop(&load_run_loop_)));
   }
 
   // Declares an expectation that PersistentCookieStore::LoadCookiesForKey
-  // will be called, saving the provided callback and sending a quit to the
-  // message loop.
-  void ExpectLoadForKeyCall(const std::string& key, bool quit_queue) {
-    if (quit_queue)
-      EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
-          .WillOnce(
-              testing::DoAll(PushCallbackAction(&loaded_for_key_callbacks_),
-                             QuitCurrentMessageLoop()));
-    else
-      EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
-          .WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
+  // will be called, saving the provided callback.
+  void ExpectLoadForKeyCall(const std::string& key) {
+    EXPECT_CALL(*persistent_store_.get(), LoadCookiesForKey(key, testing::_))
+        .WillOnce(PushCallbackAction(&loaded_for_key_callbacks_));
   }
 
   // Invokes the initial action.
   MOCK_METHOD0(Begin, void(void));
 
   // Returns the CookieMonster instance under test.
   CookieMonster& cookie_monster() { return *cookie_monster_.get(); }
 
  private:
   // Declares that mock expectations in this test suite are strictly ordered.
   testing::InSequence in_sequence_;
   // Holds cookies to be returned from PersistentCookieStore::Load or
   // PersistentCookieStore::LoadCookiesForKey.
   std::vector<CanonicalCookie*> loaded_cookies_;
   // Stores the callback passed from the CookieMonster to the
   // PersistentCookieStore::Load
   CookieMonster::PersistentCookieStore::LoadedCallback loaded_callback_;
   // Stores the callback passed from the CookieMonster to the
   // PersistentCookieStore::LoadCookiesForKey
   std::queue<CookieMonster::PersistentCookieStore::LoadedCallback>
       loaded_for_key_callbacks_;
-
+  // base::RunLoop used to wait for PersistentCookieStore::Load to be called.
+  base::RunLoop load_run_loop_;
+  // Indicates whether ExpectLoadCall() has been called.
+  bool expect_load_called_;
   // Stores the CookieMonster under test.
   scoped_refptr<CookieMonster> cookie_monster_;
   // Stores the mock PersistentCookieStore.
   scoped_refptr<NewMockPersistentCookieStore> persistent_store_;
 };
 
 TEST_F(DeferredCookieTaskTest, DeferredGetCookies) {
   DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookiesCallback get_cookies_callback;
 
   BeginWithForDomainKey(
       http_www_google_.domain(),
       GetCookiesAction(&cookie_monster(), http_www_google_.url(),
                        &get_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
       .WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
                                  &get_cookies_callback));
-  EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(get_cookies_callback, Invoke("X=1")).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookie) {
   MockSetCookiesCallback set_cookies_callback;
 
   BeginWithForDomainKey(
       http_www_google_.domain(),
       SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
                       &set_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(SetCookieAction(&cookie_monster(), http_www_google_.url(),
                                 "X=Y", &set_cookies_callback));
-  EXPECT_CALL(set_cookies_callback, Invoke(true))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetAllCookies) {
   MockSetCookiesCallback set_cookies_callback;
   CookieList list;
   list.push_back(CanonicalCookie(http_www_google_.url(), "A", "B",
                                  http_www_google_.domain(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, true, false, COOKIE_PRIORITY_DEFAULT));
   list.push_back(CanonicalCookie(http_www_google_.url(), "C", "D",
                                  http_www_google_.domain(), "/",
                                  base::Time::Now(), base::Time(), base::Time(),
                                  false, true, false, COOKIE_PRIORITY_DEFAULT));
 
   BeginWith(
       SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(
           SetAllCookiesAction(&cookie_monster(), list, &set_cookies_callback));
-  EXPECT_CALL(set_cookies_callback, Invoke(true))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCookie) {
   MockClosure delete_cookie_callback;
 
   BeginWithForDomainKey(
       http_www_google_.domain(),
       DeleteCookieAction(&cookie_monster(), http_www_google_.url(), "A",
                          &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Invoke())
       .WillOnce(DeleteCookieAction(&cookie_monster(), http_www_google_.url(),
                                    "X", &delete_cookie_callback));
-  EXPECT_CALL(delete_cookie_callback, Invoke())
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(delete_cookie_callback, Invoke()).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredSetCookieWithDetails) {
   MockSetCookiesCallback set_cookies_callback;
 
   CookiesInputInfo cookie_info = {www_google_foo_.url(),
                                   "A",
                                   "B",
                                   std::string(),
                                   "/foo",
@@ skipping 15 matching lines @@
                                       std::string(),
                                       "/foo",
                                       base::Time(),
                                       false,
                                       false,
                                       false,
                                       COOKIE_PRIORITY_DEFAULT};
   EXPECT_CALL(set_cookies_callback, Invoke(true))
       .WillOnce(SetCookieWithDetailsAction(&cookie_monster(), cookie_info_exp,
                                            &set_cookies_callback));
-  EXPECT_CALL(set_cookies_callback, Invoke(true))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(set_cookies_callback, Invoke(true)).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllCookies) {
   DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
   BeginWith(GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(
           GetAllCookiesAction(&cookie_monster(), &get_cookie_list_callback));
+  base::RunLoop loop;
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
-      .WillOnce(QuitCurrentMessageLoop());
+      .WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlCookies) {
   DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
   BeginWithForDomainKey(
       http_www_google_.domain(),
       GetAllCookiesForUrlAction(&cookie_monster(), http_www_google_.url(),
                                 &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(GetAllCookiesForUrlAction(&cookie_monster(),
                                           http_www_google_.url(),
                                           &get_cookie_list_callback));
+  base::RunLoop loop;
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
-      .WillOnce(QuitCurrentMessageLoop());
+      .WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredGetAllForUrlWithOptionsCookies) {
   DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookieListCallback get_cookie_list_callback;
 
   BeginWithForDomainKey(http_www_google_.domain(),
                         GetAllCookiesForUrlWithOptionsAction(
                             &cookie_monster(), http_www_google_.url(),
                             &get_cookie_list_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
       .WillOnce(GetAllCookiesForUrlWithOptionsAction(
           &cookie_monster(), http_www_google_.url(),
           &get_cookie_list_callback));
+  base::RunLoop loop;
   EXPECT_CALL(get_cookie_list_callback, Invoke(testing::_))
-      .WillOnce(QuitCurrentMessageLoop());
+      .WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWith(DeleteAllAction(&cookie_monster(), &delete_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(DeleteAllAction(&cookie_monster(), &delete_callback));
-  EXPECT_CALL(delete_callback, Invoke(false))
-      .WillOnce(QuitCurrentMessageLoop());
 
-  CompleteLoadingAndWait();
+  base::RunLoop loop;
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
+
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllCreatedBetweenCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWith(DeleteAllCreatedBetweenAction(&cookie_monster(), base::Time(),
                                           base::Time::Now(), &delete_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(DeleteAllCreatedBetweenAction(&cookie_monster(), base::Time(),
                                               base::Time::Now(),
                                               &delete_callback));
-  EXPECT_CALL(delete_callback, Invoke(false))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteAllForHostCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWithForDomainKey(
       http_www_google_.domain(),
       DeleteAllForHostAction(&cookie_monster(), http_www_google_.url(),
                              &delete_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(DeleteAllForHostAction(
           &cookie_monster(), http_www_google_.url(), &delete_callback));
-  EXPECT_CALL(delete_callback, Invoke(false))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteCanonicalCookie) {
   std::vector<CanonicalCookie*> cookies;
   CanonicalCookie cookie = BuildCanonicalCookie(
       http_www_google_.host(), "X=1; path=/", base::Time::Now());
 
   MockDeleteCookieCallback delete_cookie_callback;
 
   BeginWith(DeleteCanonicalCookieAction(&cookie_monster(), cookie,
                                         &delete_cookie_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_cookie_callback, Invoke(false))
       .WillOnce(DeleteCanonicalCookieAction(&cookie_monster(), cookie,
                                             &delete_cookie_callback));
+  base::RunLoop loop;
   EXPECT_CALL(delete_cookie_callback, Invoke(false))
-      .WillOnce(QuitCurrentMessageLoop());
+      .WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(DeferredCookieTaskTest, DeferredDeleteSessionCookies) {
   MockDeleteCallback delete_callback;
 
   BeginWith(DeleteSessionCookiesAction(&cookie_monster(), &delete_callback));
 
   WaitForLoadCall();
 
   EXPECT_CALL(delete_callback, Invoke(false))
       .WillOnce(
           DeleteSessionCookiesAction(&cookie_monster(), &delete_callback));
-  EXPECT_CALL(delete_callback, Invoke(false))
-      .WillOnce(QuitCurrentMessageLoop());
+  base::RunLoop loop;
+  EXPECT_CALL(delete_callback, Invoke(false)).WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 // Verify that a series of queued tasks are executed in order upon loading of
 // the backing store and that new tasks received while the queued tasks are
 // being dispatched go to the end of the queue.
 TEST_F(DeferredCookieTaskTest, DeferredTaskOrder) {
   DeclareLoadedCookie(http_www_google_.host(),
                       "X=1; path=/; expires=Mon, 18-Apr-22 22:50:14 GMT",
                       Time::Now() + TimeDelta::FromDays(3));
 
   MockGetCookiesCallback get_cookies_callback;
   MockSetCookiesCallback set_cookies_callback;
   MockGetCookiesCallback get_cookies_callback_deferred;
 
   EXPECT_CALL(*this, Begin())
       .WillOnce(testing::DoAll(
           GetCookiesAction(&cookie_monster(), http_www_google_.url(),
                            &get_cookies_callback),
           SetCookieAction(&cookie_monster(), http_www_google_.url(), "A=B",
                           &set_cookies_callback)));
   ExpectLoadCall();
-  ExpectLoadForKeyCall(http_www_google_.domain(), false);
+  ExpectLoadForKeyCall(http_www_google_.domain());
   Begin();
 
   WaitForLoadCall();
   EXPECT_CALL(get_cookies_callback, Invoke("X=1"))
       .WillOnce(GetCookiesAction(&cookie_monster(), http_www_google_.url(),
                                  &get_cookies_callback_deferred));
   EXPECT_CALL(set_cookies_callback, Invoke(true));
+  base::RunLoop loop;
   EXPECT_CALL(get_cookies_callback_deferred, Invoke("A=B; X=1"))
-      .WillOnce(QuitCurrentMessageLoop());
+      .WillOnce(QuitRunLoop(&loop));
 
-  CompleteLoadingAndWait();
+  CompleteLoading();
+  loop.Run();
 }
 
 TEST_F(CookieMonsterTest, TestCookieDeleteAll) {
   scoped_refptr<MockPersistentCookieStore> store(new MockPersistentCookieStore);
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
   CookieOptions options;
   options.set_include_httponly();
 
   EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), kValidCookieLine));
   EXPECT_EQ("A=B", GetCookies(cm.get(), http_www_google_.url()));
@@ skipping 1371 matching lines @@
                                  ResultSavingCookieCallback<bool>* callback) {
     cm->DeleteCanonicalCookieAsync(
         cookie, base::Bind(&ResultSavingCookieCallback<bool>::Run,
                            base::Unretained(callback)));
   }
 
  protected:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.task_runner()->PostTask(FROM_HERE, task);
-    RunFor(kTimeout);
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
 
 }  // namespace
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookies) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
   CookieList cookies = GetAllCookies(cm.get());
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::GetAllCookiesTask,
                  base::Unretained(this), cm, &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
   EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURL) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
   CookieList cookies = GetAllCookiesForURL(cm.get(), http_www_google_.url());
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::GetAllCookiesForURLTask,
                  base::Unretained(this), cm, http_www_google_.url(), &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
   EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckGetAllCookiesForURLWithOpt) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   EXPECT_TRUE(SetCookie(cm.get(), http_www_google_.url(), "A=B"));
   CookieOptions options;
   CookieList cookies =
       GetAllCookiesForURLWithOptions(cm.get(), http_www_google_.url(), options);
   CookieList::const_iterator it = cookies.begin();
   ASSERT_TRUE(it != cookies.end());
   EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == cookies.end());
   GetCookieListCallback callback(&other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieMonsterTest::GetAllCookiesForURLWithOptionsTask,
       base::Unretained(this), cm, http_www_google_.url(), options, &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   it = callback.cookies().begin();
   ASSERT_TRUE(it != callback.cookies().end());
   EXPECT_EQ(http_www_google_.host(), it->Domain());
   EXPECT_EQ("A", it->Name());
   ASSERT_TRUE(++it == callback.cookies().end());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckSetCookieWithDetails) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   EXPECT_TRUE(SetCookieWithDetails(cm.get(), www_google_foo_.url(), "A", "B",
                                    std::string(), "/foo", base::Time(), false,
                                    false, false, COOKIE_PRIORITY_DEFAULT));
   ResultSavingCookieCallback<bool> callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::SetCookieWithDetailsTask,
                  base::Unretained(this), cm, www_google_foo_.url(), &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllCreatedBetween) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   Time now = Time::Now();
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   EXPECT_EQ(1, DeleteAllCreatedBetween(cm.get(), now - TimeDelta::FromDays(99),
                                        Time()));
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<int> callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenTask,
                  base::Unretained(this), cm, now - TimeDelta::FromDays(99),
                  Time(), &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteAllForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   EXPECT_EQ(1, DeleteAllForHost(cm.get(), http_www_google_.url()));
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<int> callback(&other_thread_);
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteAllForHostTask,
                  base::Unretained(this), cm, http_www_google_.url(), &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   EXPECT_EQ(1, callback.result());
 }
 
 TEST_F(MultiThreadedCookieMonsterTest,
        ThreadCheckDeleteAllCreatedBetweenForHost) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   GURL url_not_google("http://www.notgoogle.com");
 
   CookieOptions options;
   Time now = Time::Now();
@@ skipping 26 matching lines @@
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<int> callback(&other_thread_);
 
   // 2. Second set of deletions.
   base::Closure task = base::Bind(
       &MultiThreadedCookieMonsterTest::DeleteAllCreatedBetweenForHostTask,
       base::Unretained(this), cm, ago1, Time(), http_www_google_.url(),
       &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   EXPECT_EQ(2, callback.result());  // Deletes A=B, G=H.
 }
 
 TEST_F(MultiThreadedCookieMonsterTest, ThreadCheckDeleteCanonicalCookie) {
   scoped_refptr<CookieMonster> cm(new CookieMonster(NULL, NULL));
   CookieOptions options;
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   CookieList cookies = GetAllCookies(cm.get());
   CookieList::iterator it = cookies.begin();
   EXPECT_TRUE(DeleteCanonicalCookie(cm.get(), *it));
 
   EXPECT_TRUE(
       SetCookieWithOptions(cm.get(), http_www_google_.url(), "A=B", options));
   ResultSavingCookieCallback<bool> callback(&other_thread_);
   cookies = GetAllCookies(cm.get());
   it = cookies.begin();
   base::Closure task =
       base::Bind(&MultiThreadedCookieMonsterTest::DeleteCanonicalCookieTask,
                  base::Unretained(this), cm, *it, &callback);
   RunOnOtherThread(task);
-  EXPECT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.result());
 }
 
 // Ensure that cookies for http, https, ws, and wss all share the same storage
 // and policies when GetAllCookiesForURLAsync is used. This test is part of
 // MultiThreadedCookieMonsterTest in order to test and use
 // GetAllCookiesForURLAsync, but it does not use any additional threads.
 TEST_F(MultiThreadedCookieMonsterTest, GetAllCookiesForURLEffectiveDomain) {
   scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
       http_www_google_.url(), kValidCookieLine, Time::Now(), CookieOptions()));
@@ skipping 17 matching lines @@
   EXPECT_CALL(checkpoint, Call(1));
   // LoadCookiesForKey will never be called after checkpoint.Call(1) although
   // we will call GetAllCookiesForURLAsync again, because all URLs below share
   // the same key.
   EXPECT_CALL(*store, LoadCookiesForKey(::testing::_, ::testing::_)).Times(0);
 
   GetCookieListCallback callback;
   checkpoint.Call(0);
   GetAllCookiesForURLTask(cm.get(), http_www_google_.url(), &callback);
   checkpoint.Call(1);
-  ASSERT_FALSE(callback.did_run());
   // Pass the cookies to the CookieMonster.
   loaded_callback.Run(cookies);
   // Now GetAllCookiesForURLTask is done.
-  ASSERT_TRUE(callback.did_run());
+  callback.WaitUntilDone();
   // See that the callback was called with the cookies.
   ASSERT_EQ(1u, callback.cookies().size());
   EXPECT_TRUE(cookie->IsEquivalent(callback.cookies()[0]));
 
   // All urls in |urls| should share the same cookie domain.
   const GURL kUrls[] = {
       http_www_google_.url(), https_www_google_.url(), ws_www_google_.url(),
       wss_www_google_.url(),
   };
   for (const GURL& url : kUrls) {
     // Call the function with |url| and verify it is done synchronously without
     // calling LoadCookiesForKey.
     GetCookieListCallback callback;
     GetAllCookiesForURLTask(cm.get(), url, &callback);
-    ASSERT_TRUE(callback.did_run());
+    callback.WaitUntilDone();
     ASSERT_EQ(1u, callback.cookies().size());
     EXPECT_TRUE(cookie->IsEquivalent(callback.cookies()[0]));
   }
 }
 
 TEST_F(CookieMonsterTest, InvalidExpiryTime) {
   std::string cookie_line =
       std::string(kValidCookieLine) + "; expires=Blarg arg arg";
   scoped_ptr<CanonicalCookie> cookie(CanonicalCookie::Create(
       http_www_google_.url(), cookie_line, Time::Now(), CookieOptions()));
@@ skipping 690 matching lines @@
       monster()->AddCallbackForCookie(
           test_url_, "abc",
           base::Bind(&RecordCookieChanges, &cookies1, nullptr)));
   SetCookie(monster(), test_url_, "abc=def");
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(1U, cookies0.size());
   EXPECT_EQ(1U, cookies0.size());
 }
 
 }  // namespace net