Move the thread test helper to base/test

chrome/browser/net/sqlite_persistent_cookie_store_unittest.cc

 // Copyright (c) 2011 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/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/scoped_temp_dir.h"
 #include "base/stl_util-inl.h"
+#include "base/test/thread_test_helper.h"
 #include "base/time.h"
 #include "chrome/browser/net/sqlite_persistent_cookie_store.h"
 #include "chrome/common/chrome_constants.h"
-#include "chrome/test/thread_test_helper.h"
 #include "content/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class SQLitePersistentCookieStoreTest : public testing::Test {
  public:
   SQLitePersistentCookieStoreTest()
       : ui_thread_(BrowserThread::UI),
         db_thread_(BrowserThread::DB) {
   }
@@ skipping 21 matching lines @@
   BrowserThread ui_thread_;
   BrowserThread db_thread_;
   ScopedTempDir temp_dir_;
   scoped_refptr<SQLitePersistentCookieStore> store_;
 };
 
 TEST_F(SQLitePersistentCookieStoreTest, KeepOnDestruction) {
   store_->SetClearLocalStateOnExit(false);
   store_ = NULL;
   // Make sure we wait until the destructor has run.
-  scoped_refptr<ThreadTestHelper> helper(
-      new ThreadTestHelper(BrowserThread::DB));
+  scoped_refptr<base::ThreadTestHelper> helper(
+      new base::ThreadTestHelper(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   ASSERT_TRUE(helper->Run());
 
   ASSERT_TRUE(file_util::PathExists(
       temp_dir_.path().Append(chrome::kCookieFilename)));
   ASSERT_TRUE(file_util::Delete(
       temp_dir_.path().Append(chrome::kCookieFilename), false));
 }
 
 TEST_F(SQLitePersistentCookieStoreTest, RemoveOnDestruction) {
   store_->SetClearLocalStateOnExit(true);
   // Replace the store effectively destroying the current one and forcing it
   // to write it's data to disk. Then we can see if after loading it again it
   // is still there.
   store_ = NULL;
   // Make sure we wait until the destructor has run.
-  scoped_refptr<ThreadTestHelper> helper(
-      new ThreadTestHelper(BrowserThread::DB));
+  scoped_refptr<base::ThreadTestHelper> helper(
+      new base::ThreadTestHelper(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   ASSERT_TRUE(helper->Run());
 
   ASSERT_FALSE(file_util::PathExists(
       temp_dir_.path().Append(chrome::kCookieFilename)));
 }
 
 // Test if data is stored as expected in the SQLite database.
 TEST_F(SQLitePersistentCookieStoreTest, TestPersistance) {
   std::vector<net::CookieMonster::CanonicalCookie*> cookies;
   // Replace the store effectively destroying the current one and forcing it
   // to write it's data to disk. Then we can see if after loading it again it
   // is still there.
   store_ = NULL;
-  scoped_refptr<ThreadTestHelper> helper(
-      new ThreadTestHelper(BrowserThread::DB));
+  scoped_refptr<base::ThreadTestHelper> helper(
+      new base::ThreadTestHelper(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   // Make sure we wait until the destructor has run.
   ASSERT_TRUE(helper->Run());
   store_ = new SQLitePersistentCookieStore(
       temp_dir_.path().Append(chrome::kCookieFilename));
 
   // Reload and test for persistence
   ASSERT_TRUE(store_->Load(&cookies));
   ASSERT_EQ(1U, cookies.size());
   ASSERT_STREQ("http://foo.bar", cookies[0]->Domain().c_str());
   ASSERT_STREQ("A", cookies[0]->Name().c_str());
@@ skipping 32 matching lines @@
     store_->AddCookie(
         net::CookieMonster::CanonicalCookie(GURL(), name, value,
                                             "http://foo.bar", "/",
                                             std::string(), std::string(),
                                             t, t, t,
                                             false, false, true));
   }
 
   // Call Flush() and wait until the DB thread is idle.
   store_->Flush(NULL);
-  scoped_refptr<ThreadTestHelper> helper(
-      new ThreadTestHelper(BrowserThread::DB));
+  scoped_refptr<base::ThreadTestHelper> helper(
+      new base::ThreadTestHelper(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   ASSERT_TRUE(helper->Run());
 
   // We forced a write, so now the file will be bigger.
   ASSERT_TRUE(file_util::GetFileInfo(path, &info));
   ASSERT_GT(info.size, base_size);
 }
 
 // Counts the number of times Callback() has been run.
 class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> {
  public:
@@ skipping 14 matching lines @@
 
 // Test that we can get a completion callback after a Flush().
 TEST_F(SQLitePersistentCookieStoreTest, TestFlushCompletionCallback) {
   scoped_refptr<CallbackCounter> counter(new CallbackCounter());
 
   // Callback shouldn't be invoked until we call Flush().
   ASSERT_EQ(0, counter->callback_count());
 
   store_->Flush(NewRunnableMethod(counter.get(), &CallbackCounter::Callback));
 
-  scoped_refptr<ThreadTestHelper> helper(
-      new ThreadTestHelper(BrowserThread::DB));
+  scoped_refptr<base::ThreadTestHelper> helper(
+      new base::ThreadTestHelper(
+          BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB)));
   ASSERT_TRUE(helper->Run());
 
   ASSERT_EQ(1, counter->callback_count());
 }