Add TestBrowserThreadBundle into RenderViewHostTestHarness. Kill some unnecessary real threads.

components/visitedlink/test/visitedlink_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 <cstdio>
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
+#include "base/run_loop.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "components/visitedlink/browser/visitedlink_delegate.h"
 #include "components/visitedlink/browser/visitedlink_event_listener.h"
 #include "components/visitedlink/browser/visitedlink_master.h"
 #include "components/visitedlink/common/visitedlink_messages.h"
 #include "components/visitedlink/renderer/visitedlink_slave.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
-#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_renderer_host.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using content::MockRenderProcessHost;
 using content::RenderViewHostTester;
 
 namespace visitedlink {
 
@@ skipping 92 matching lines @@
   int reset_count() const { return reset_count_; }
   int add_count() const { return add_count_; }
 
  private:
   int reset_count_;
   int add_count_;
 };
 
 class VisitedLinkTest : public testing::Test {
  protected:
-  VisitedLinkTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        file_thread_(BrowserThread::FILE, &message_loop_) {}
   // Initializes the visited link objects. Pass in the size that you want a
   // freshly created table to be. 0 means use the default.
   //
   // |suppress_rebuild| is set when we're not testing rebuilding, see
   // the VisitedLinkMaster constructor.
   bool InitVisited(int initial_size, bool suppress_rebuild) {
     // Initialize the visited link system.
     master_.reset(new VisitedLinkMaster(new TrackingVisitedLinkEventListener(),
                                         &delegate_,
                                         true,
@@ skipping 64 matching lines @@
 
     visited_file_ = history_dir_.Append(FILE_PATH_LITERAL("VisitedLinks"));
   }
 
   virtual void TearDown() {
     ClearDB();
   }
 
   base::ScopedTempDir temp_dir_;
 
-  base::MessageLoop message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
-
   // Filenames for the services;
   base::FilePath history_dir_;
   base::FilePath visited_file_;
 
   scoped_ptr<VisitedLinkMaster> master_;
   TestVisitedLinkDelegate delegate_;
+  content::TestBrowserThreadBundle thread_bundle_;
 };
 
 // This test creates and reads some databases to make sure the data is
 // preserved throughout those operations.
 TEST_F(VisitedLinkTest, DatabaseIO) {
   ASSERT_TRUE(InitVisited(0, true));
 
   for (int i = 0; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
@@ skipping 186 matching lines @@
   URLs urls_to_delete;
   urls_to_delete.push_back(TestURL(g_test_count));
   TestURLIterator iterator(urls_to_delete);
   master_->DeleteURLs(&iterator);
 
   // Wait for the rebuild to complete. The task will terminate the message
   // loop when the rebuild is done. There's no chance that the rebuild will
   // complete before we set the task because the rebuild completion message
   // is posted to the message loop; until we Run() it, rebuild can not
   // complete.
-  master_->set_rebuild_complete_task(base::MessageLoop::QuitClosure());
-  base::MessageLoop::current()->Run();
+  base::RunLoop run_loop;
+  master_->set_rebuild_complete_task(run_loop.QuitClosure());
+  run_loop.Run();
 
   // Test that all URLs were written to the database properly.
   Reload();
 
   // Make sure the extra one was *not* written (Reload won't test this).
   EXPECT_FALSE(master_->IsVisited(TestURL(g_test_count)));
 }
 
 // Test that importing a large number of URLs will work
 TEST_F(VisitedLinkTest, BigImport) {
   ASSERT_TRUE(InitVisited(0, false));
 
   // Before the table rebuilds, add a large number of URLs
   int total_count = VisitedLinkMaster::kDefaultTableSize + 10;
   for (int i = 0; i < total_count; i++)
     master_->AddURL(TestURL(i));
 
   // Wait for the rebuild to complete.
-  master_->set_rebuild_complete_task(base::MessageLoop::QuitClosure());
-  base::MessageLoop::current()->Run();
+  base::RunLoop run_loop;
+  master_->set_rebuild_complete_task(run_loop.QuitClosure());
+  run_loop.Run();
 
   // Ensure that the right number of URLs are present
   int used_count = master_->GetUsedCount();
   ASSERT_EQ(used_count, total_count);
 }
 
 TEST_F(VisitedLinkTest, Listener) {
   ASSERT_TRUE(InitVisited(0, true));
 
   // Add test URLs.
@@ skipping 112 matching lines @@
     return new VisitRelayingRenderProcessHost(browser_context);
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkRenderProcessHostFactory);
 };
 
 class VisitedLinkEventsTest : public content::RenderViewHostTestHarness {
  public:
-  VisitedLinkEventsTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        file_thread_(BrowserThread::FILE, &message_loop_) {}
-  virtual ~VisitedLinkEventsTest() {}
   virtual void SetUp() {
     browser_context_.reset(new VisitCountingContext());
     master_.reset(new VisitedLinkMaster(context(), &delegate_, true));
     master_->Init();
     SetRenderProcessHostFactory(&vc_rph_factory_);
     content::RenderViewHostTestHarness::SetUp();
   }
 
   VisitCountingContext* context() const {
     return static_cast<VisitCountingContext*>(browser_context_.get());
   }
 
   VisitedLinkMaster* master() const {
     return master_.get();
   }
 
   void WaitForCoalescense() {
     // Let the timer fire.
+    //
+    // TODO(ajwong): This is horrid! What is the right synchronization method?
+    base::RunLoop run_loop;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        base::MessageLoop::QuitClosure(),
+        run_loop.QuitClosure(),
         base::TimeDelta::FromMilliseconds(110));
-    base::MessageLoop::current()->Run();
+    run_loop.Run();
   }
 
  protected:
   VisitedLinkRenderProcessHostFactory vc_rph_factory_;
 
  private:
   TestVisitedLinkDelegate delegate_;
   scoped_ptr<VisitedLinkMaster> master_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
-
-  DISALLOW_COPY_AND_ASSIGN(VisitedLinkEventsTest);
 };
 
 TEST_F(VisitedLinkEventsTest, Coalescense) {
   // add some URLs to master.
   // Add a few URLs.
   master()->AddURL(GURL("http://acidtests.org/"));
   master()->AddURL(GURL("http://google.com/"));
   master()->AddURL(GURL("http://chromium.org/"));
   // Just for kicks, add a duplicate URL. This shouldn't increase the resulting
   master()->AddURL(GURL("http://acidtests.org/"));
@@ skipping 123 matching lines @@
       content::NOTIFICATION_RENDERER_PROCESS_CREATED,
       content::Source<content::RenderProcessHost>(&different_process_host),
       content::NotificationService::NoDetails());
   WaitForCoalescense();
 
   EXPECT_EQ(0, different_context.new_table_count());
 
 }
 
 }  // namespace visitedlink