Convert CookieMonster tests to use base::RunLoop

net/cookies/cookie_store_unittest.h

 // 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.
 
 #ifndef NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 #define NET_COOKIES_COOKIE_STORE_UNITTEST_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 91 matching lines @@
   std::string GetCookies(CookieStore* cs, const GURL& url) {
     DCHECK(cs);
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
       options.set_include_httponly();
     StringResultCookieCallback callback;
     cs->GetCookiesWithOptionsAsync(
         url, options,
         base::Bind(&StringResultCookieCallback::Run,
                    base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   std::string GetCookiesWithOptions(CookieStore* cs,
                                     const GURL& url,
                                     const CookieOptions& options) {
     DCHECK(cs);
     StringResultCookieCallback callback;
     cs->GetCookiesWithOptionsAsync(
         url, options, base::Bind(&StringResultCookieCallback::Run,
                                  base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   CookieList GetAllCookies(CookieStore* cs) {
     DCHECK(cs);
     GetCookieListCallback callback;
     cs->GetAllCookiesAsync(
         base::Bind(&GetCookieListCallback::Run, base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.cookies();
   }
 
   bool SetCookieWithOptions(CookieStore* cs,
                             const GURL& url,
                             const std::string& cookie_line,
                             const CookieOptions& options) {
     DCHECK(cs);
     ResultSavingCookieCallback<bool> callback;
     cs->SetCookieWithOptionsAsync(
         url, cookie_line, options,
         base::Bind(
             &ResultSavingCookieCallback<bool>::Run,
             base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   bool SetCookieWithServerTime(CookieStore* cs,
                                const GURL& url,
                                const std::string& cookie_line,
                                const base::Time& server_time) {
     CookieOptions options;
     if (!CookieStoreTestTraits::supports_http_only)
@@ skipping 14 matching lines @@
   }
 
   void DeleteCookie(CookieStore* cs,
                     const GURL& url,
                     const std::string& cookie_name) {
     DCHECK(cs);
     NoResultCookieCallback callback;
     cs->DeleteCookieAsync(
         url, cookie_name,
         base::Bind(&NoResultCookieCallback::Run, base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
   }
 
   int DeleteCreatedBetween(CookieStore* cs,
                             const base::Time& delete_begin,
                             const base::Time& delete_end) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
     cs->DeleteAllCreatedBetweenAsync(
         delete_begin, delete_end,
         base::Bind(
             &ResultSavingCookieCallback<int>::Run,
             base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   int DeleteAllCreatedBetweenForHost(CookieStore* cs,
                                      const base::Time delete_begin,
                                      const base::Time delete_end,
                                      const GURL& url) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
     cs->DeleteAllCreatedBetweenForHostAsync(
         delete_begin, delete_end, url,
         base::Bind(
             &ResultSavingCookieCallback<int>::Run,
             base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
   int DeleteSessionCookies(CookieStore* cs) {
     DCHECK(cs);
     ResultSavingCookieCallback<int> callback;
     cs->DeleteSessionCookiesAsync(
         base::Bind(
             &ResultSavingCookieCallback<int>::Run,
             base::Unretained(&callback)));
-    RunFor(kTimeout);
+    callback.WaitUntilDone();
     EXPECT_TRUE(callback.did_run());
     return callback.result();
   }
 
-  void RunFor(int ms) {
-    // Runs the test thread message loop for up to |ms| milliseconds.
-    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
-        FROM_HERE, base::Bind(&base::MessageLoop::QuitWhenIdle,
-                              weak_factory_->GetWeakPtr()),
-        base::TimeDelta::FromMilliseconds(ms));
-    base::MessageLoop::current()->Run();
-    weak_factory_->InvalidateWeakPtrs();
-  }
-
   scoped_refptr<CookieStore> GetCookieStore() {
     return CookieStoreTestTraits::Create();
   }
 
   // Compares two cookie lines.
   void MatchCookieLines(const std::string& line1, const std::string& line2) {
     EXPECT_EQ(TokenizeCookieLine(line1), TokenizeCookieLine(line2));
   }
 
   // Check the cookie line by polling until equality or a timeout is reached.
@@ skipping 958 matching lines @@
     cs->DeleteSessionCookiesAsync(
         base::Bind(
             &ResultSavingCookieCallback<int>::Run,
             base::Unretained(callback)));
   }
 
  protected:
   void RunOnOtherThread(const base::Closure& task) {
     other_thread_.Start();
     other_thread_.task_runner()->PostTask(FROM_HERE, task);
-    CookieStoreTest<CookieStoreTestTraits>::RunFor(kTimeout);
     other_thread_.Stop();
   }
 
   Thread other_thread_;
 };
 
 TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest);
 
 // TODO(ycxiao): Eventually, we will need to create a separate thread, create
 // the cookie store on that thread (or at least its store, i.e., the DB
 // thread).
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   EXPECT_TRUE(this->SetCookie(cs.get(), this->http_www_google_.url(), "A=B"));
   this->MatchCookieLines(
       "A=B", this->GetCookies(cs.get(), this->http_www_google_.url()));
   StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieStoreTest<TypeParam>::GetCookiesTask,
       base::Unretained(this), cs, this->http_www_google_.url(), &callback);
   this->RunOnOtherThread(task);
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckGetCookiesWithOptions) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookie(cs.get(), this->http_www_google_.url(), "A=B"));
   this->MatchCookieLines(
       "A=B", this->GetCookiesWithOptions(cs.get(), this->http_www_google_.url(),
                                          options));
   StringResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieStoreTest<TypeParam>::GetCookiesWithOptionsTask,
       base::Unretained(this), cs, this->http_www_google_.url(), options,
       &callback);
   this->RunOnOtherThread(task);
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ("A=B", callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckSetCookieWithOptions) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs.get(), this->http_www_google_.url(),
                                          "A=B", options));
   ResultSavingCookieCallback<bool> callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieStoreTest<TypeParam>::SetCookieWithOptionsTask,
       base::Unretained(this), cs, this->http_www_google_.url(), "A=B", options,
       &callback);
   this->RunOnOtherThread(task);
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.did_run());
   EXPECT_TRUE(callback.result());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteCookie) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs.get(), this->http_www_google_.url(),
                                          "A=B", options));
   this->DeleteCookie(cs.get(), this->http_www_google_.url(), "A");
   EXPECT_TRUE(this->SetCookieWithOptions(cs.get(), this->http_www_google_.url(),
                                          "A=B", options));
   NoResultCookieCallback callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieStoreTest<TypeParam>::DeleteCookieTask,
       base::Unretained(this), cs, this->http_www_google_.url(), "A", &callback);
   this->RunOnOtherThread(task);
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.did_run());
 }
 
 TYPED_TEST_P(MultiThreadedCookieStoreTest, ThreadCheckDeleteSessionCookies) {
   scoped_refptr<CookieStore> cs(this->GetCookieStore());
   CookieOptions options;
   if (!TypeParam::supports_http_only)
     options.set_include_httponly();
   EXPECT_TRUE(this->SetCookieWithOptions(cs.get(), this->http_www_google_.url(),
                                          "A=B", options));
   EXPECT_TRUE(this->SetCookieWithOptions(
       cs.get(), this->http_www_google_.url(),
       "B=C; expires=Mon, 18-Apr-22 22:50:13 GMT", options));
   EXPECT_EQ(1, this->DeleteSessionCookies(cs.get()));
   EXPECT_EQ(0, this->DeleteSessionCookies(cs.get()));
   EXPECT_TRUE(this->SetCookieWithOptions(cs.get(), this->http_www_google_.url(),
                                          "A=B", options));
   ResultSavingCookieCallback<int> callback(&this->other_thread_);
   base::Closure task = base::Bind(
       &MultiThreadedCookieStoreTest<TypeParam>::DeleteSessionCookiesTask,
       base::Unretained(this), cs, &callback);
   this->RunOnOtherThread(task);
+  callback.WaitUntilDone();
   EXPECT_TRUE(callback.did_run());
   EXPECT_EQ(1, callback.result());
 }
 
 REGISTER_TYPED_TEST_CASE_P(MultiThreadedCookieStoreTest,
                            ThreadCheckGetCookies,
                            ThreadCheckGetCookiesWithOptions,
                            ThreadCheckSetCookieWithOptions,
                            ThreadCheckDeleteCookie,
                            ThreadCheckDeleteSessionCookies);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_STORE_UNITTEST_H_