Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/visitedlink_unittest.cc

 // Copyright (c) 2006-2008 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 <vector>
 #include <string>
 #include <cstdio>
 
 #include "base/message_loop.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/browser/visitedlink_event_listener.h"
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 #include "chrome/browser/renderer_host/test/test_render_view_host.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/visitedlink_slave.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ skipping 39 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_(ChromeThread::UI, &message_loop_),
+        file_thread_(ChromeThread::FILE, &message_loop_) {}
   // Initialize the history system. This should be called before InitVisited().
   bool InitHistory() {
     history_service_ = new HistoryService;
     return history_service_->Init(history_dir_, NULL);
   }
 
   // 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(NULL, &listener_, history_service_,
+    master_.reset(new VisitedLinkMaster(&listener_, history_service_,
                                         suppress_rebuild, visited_file_,
                                         initial_size));
     return master_->Init();
   }
 
   // May be called multiple times (some tests will do this to clear things,
   // and TearDown will do this to make sure eveything is shiny before quitting.
   void ClearDB() {
     if (master_.get())
       master_.reset(NULL);
@@ skipping 65 matching lines @@
     visited_file_ = history_dir_.Append(FILE_PATH_LITERAL("VisitedLinks"));
     listener_.SetUp();
   }
 
   virtual void TearDown() {
     ClearDB();
     file_util::Delete(history_dir_, true);
   }
 
   MessageLoop message_loop_;
+  ChromeThread ui_thread_;
+  ChromeThread file_thread_;
 
   // Filenames for the services;
   FilePath history_dir_;
   FilePath visited_file_;
 
   scoped_ptr<VisitedLinkMaster> master_;
   scoped_refptr<HistoryService> history_service_;
   TrackingVisitedLinkEventListener listener_;
 };
 
@@ skipping 262 matching lines @@
 class VisitCountingProfile : public TestingProfile {
  public:
   explicit VisitCountingProfile(VisitedLinkEventListener* event_listener)
       : add_count_(0),
         add_event_count_(0),
         reset_event_count_(0),
         event_listener_(event_listener) {}
 
   virtual VisitedLinkMaster* GetVisitedLinkMaster() {
     if (!visited_link_master_.get()) {
-      visited_link_master_.reset(
-          new VisitedLinkMaster(NULL, event_listener_, this));
+      visited_link_master_.reset(new VisitedLinkMaster(event_listener_, this));
       visited_link_master_->Init();
     }
     return visited_link_master_.get();
   }
 
   void CountAddEvent(int by) {
     add_count_ += by;
     add_event_count_++;
   }
 
@@ skipping 96 matching lines @@
   void set_relay_mode(bool mode) { relay_mode_ = mode; }
 
  private:
   bool relay_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkRenderProcessHostFactory);
 };
 
 class VisitedLinkEventsTest : public RenderViewHostTestHarness {
  public:
-  VisitedLinkEventsTest() : RenderViewHostTestHarness() {}
+  VisitedLinkEventsTest()
+      : RenderViewHostTestHarness(),
+        file_thread_(ChromeThread::FILE, &message_loop_) {}
+  ~VisitedLinkEventsTest() {
+    // This ends up using the file thread to schedule the delete.
+    profile_.reset();
+    message_loop_.RunAllPending();
+  }
   virtual void SetFactoryMode() {}
   virtual void SetUp() {
     SetFactoryMode();
     event_listener_.reset(new VisitedLinkEventListener());
     rvh_factory_.set_render_process_host_factory(&vc_rph_factory_);
     profile_.reset(new VisitCountingProfile(event_listener_.get()));
     RenderViewHostTestHarness::SetUp();
   }
 
   VisitCountingProfile* profile() const {
     return static_cast<VisitCountingProfile*>(profile_.get());
   }
 
   void WaitForCoalescense() {
     // Let the timer fire.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                             new MessageLoop::QuitTask(), 110);
     MessageLoop::current()->Run();
   }
 
  protected:
   VisitedLinkRenderProcessHostFactory vc_rph_factory_;
 
  private:
   scoped_ptr<VisitedLinkEventListener> event_listener_;
+  ChromeThread file_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkEventsTest);
 };
 
 class VisitedLinkRelayTest : public VisitedLinkEventsTest {
  public:
   virtual void SetFactoryMode() { vc_rph_factory_.set_relay_mode(true); }
 };
 
 TEST_F(VisitedLinkEventsTest, Coalescense) {
@@ skipping 138 matching lines @@
   EXPECT_EQ(0, profile()->add_event_count());
   EXPECT_EQ(0, profile()->reset_event_count());
 
   rvh()->CreateRenderView();
 
   // We should now have just a reset event: adds are eaten up by a reset
   // that followed.
   EXPECT_EQ(0, profile()->add_event_count());
   EXPECT_EQ(1, profile()->reset_event_count());
 }