Remove VisitedLink dependency on rest of chrome

chrome/browser/visitedlink/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/shared_memory.h"
 #include "base/string_util.h"
 #include "base/time.h"
+#include "chrome/browser/visitedlink/visitedlink_delegate.h"
 #include "chrome/browser/visitedlink/visitedlink_event_listener.h"
 #include "chrome/browser/visitedlink/visitedlink_master.h"
-#include "chrome/browser/visitedlink/visitedlink_master_factory.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/visitedlink_slave.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.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_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 {
 
+typedef std::vector<GURL> URLs;
+
 // a nice long URL that we can append numbers to to get new URLs
 const char g_test_prefix[] =
   "http://www.google.com/products/foo/index.html?id=45028640526508376&seq=";
 const int g_test_count = 1000;
 
 // Returns a test URL for index |i|
 GURL TestURL(int i) {
   return GURL(StringPrintf("%s%d", g_test_prefix, i));
 }
 
-ProfileKeyedService* BuildVisitedLinkMaster(Profile* profile) {
-  VisitedLinkMaster* master = new VisitedLinkMaster(profile);
-  master->Init();
-  return master;
-}
-
 std::vector<VisitedLinkSlave*> g_slaves;
 
+class TestVisitedLinkDelegate : public VisitedLinkDelegate {
+ public:
+  virtual bool AreEquivalentContexts(
+      content::BrowserContext* context1,
+      content::BrowserContext* context2) OVERRIDE;
+  virtual void RebuildTable(
+      const scoped_refptr<URLEnumerator>& enumerator) OVERRIDE;
+
+  void AddURLForRebuild(const GURL& url);
+
+ private:
+
+  URLs rebuild_urls_;
+};
+
+bool TestVisitedLinkDelegate::AreEquivalentContexts(
+    content::BrowserContext* context1, content::BrowserContext* context2) {
+  DCHECK_EQ(context1, context2);
+  return true;  // Test only has one profile.
+}
+
+void TestVisitedLinkDelegate::RebuildTable(
+    const scoped_refptr<URLEnumerator>& enumerator) {
+  for (URLs::const_iterator itr = rebuild_urls_.begin();
+       itr != rebuild_urls_.end();
+       ++itr)
+    enumerator->OnURL(*itr);
+  enumerator->OnComplete(true);
+}
+
+void TestVisitedLinkDelegate::AddURLForRebuild(const GURL& url) {
+  rebuild_urls_.push_back(url);
+}
+
+class TestURLIterator : public VisitedLinkMaster::URLIterator {
+ public:
+  explicit TestURLIterator(const URLs& urls);
+
+  virtual const GURL& NextURL() OVERRIDE;
+  virtual bool HasNextURL() const OVERRIDE;
+
+ private:
+  URLs::const_iterator iterator_;
+  URLs::const_iterator end_;
+};
+
+TestURLIterator::TestURLIterator(const URLs& urls)
+    : iterator_(urls.begin()),
+      end_(urls.end()) {
+}
+
+const GURL& TestURLIterator::NextURL() {
+  return *(iterator_++);
+}
+
+bool TestURLIterator::HasNextURL() const {
+  return iterator_ != end_;
+}
+
 }  // namespace
 
 class TrackingVisitedLinkEventListener : public VisitedLinkMaster::Listener {
  public:
   TrackingVisitedLinkEventListener()
       : reset_count_(0),
         add_count_(0) {}
 
   virtual void NewTable(base::SharedMemory* table) {
     if (table) {
@@ skipping 19 matching lines @@
  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_) {}
-  // Initialize the history system. This should be called before InitVisited().
-  bool InitHistory() {
-    history_service_.reset(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(new TrackingVisitedLinkEventListener(),
-                                        history_service_.get(),
+                                        &delegate_,
                                         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);
 
-    if (history_service_.get()) {
-      history_service_->SetOnBackendDestroyTask(MessageLoop::QuitClosure());
-      history_service_->Cleanup();
-      history_service_.reset();
-
-      // Wait for the backend class to terminate before deleting the files and
-      // moving to the next test. Note: if this never terminates, somebody is
-      // probably leaking a reference to the history backend, so it never calls
-      // our destroy task.
-      MessageLoop::current()->Run();
-    }
-
     // Wait for all pending file I/O to be completed.
     BrowserThread::GetBlockingPool()->FlushForTesting();
   }
 
   // Loads the database from disk and makes sure that the same URLs are present
   // as were generated by TestIO_Create(). This also checks the URLs with a
   // slave to make sure it reads the data properly.
   void Reload() {
     // Clean up after our caller, who may have left the database open.
     ClearDB();
 
-    ASSERT_TRUE(InitHistory());
     ASSERT_TRUE(InitVisited(0, true));
     master_->DebugValidate();
 
     // check that the table has the proper number of entries
     int used_count = master_->GetUsedCount();
     ASSERT_EQ(used_count, g_test_count);
 
     // Create a slave database.
     VisitedLinkSlave slave;
     base::SharedMemoryHandle new_handle = base::SharedMemory::NULLHandle();
@@ skipping 41 matching lines @@
 
   MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   // Filenames for the services;
   FilePath history_dir_;
   FilePath visited_file_;
 
   scoped_ptr<VisitedLinkMaster> master_;
-  scoped_ptr<HistoryService> history_service_;
+  TestVisitedLinkDelegate delegate_;
 };
 
 // This test creates and reads some databases to make sure the data is
 // preserved throughout those operations.
 TEST_F(VisitedLinkTest, DatabaseIO) {
-  ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(0, true));
 
   for (int i = 0; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
   // Test that the database was written properly
   Reload();
 }
 
 // Checks that we can delete things properly when there are collisions.
 TEST_F(VisitedLinkTest, Delete) {
   static const int32 kInitialSize = 17;
-  ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(kInitialSize, true));
 
   // Add a cluster from 14-17 wrapping around to 0. These will all hash to the
   // same value.
   const VisitedLinkCommon::Fingerprint kFingerprint0 = kInitialSize * 0 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint1 = kInitialSize * 1 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint2 = kInitialSize * 2 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint3 = kInitialSize * 3 + 14;
   const VisitedLinkCommon::Fingerprint kFingerprint4 = kInitialSize * 4 + 14;
   master_->AddFingerprint(kFingerprint0, false);  // @14
@@ skipping 18 matching lines @@
 
   EXPECT_EQ(0, master_->used_items_);
   for (int i = 0; i < kInitialSize; i++)
     EXPECT_EQ(zero_fingerprint, master_->hash_table_[i]) <<
         "Hash table has values in it.";
 }
 
 // When we delete more than kBigDeleteThreshold we trigger different behavior
 // where the entire file is rewritten.
 TEST_F(VisitedLinkTest, BigDelete) {
-  ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(16381, true));
 
   // Add the base set of URLs that won't be deleted.
   // Reload() will test for these.
   for (int32 i = 0; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
   // Add more URLs than necessary to trigger this case.
   const int kTestDeleteCount = VisitedLinkMaster::kBigDeleteThreshold + 2;
-  history::URLRows urls_to_delete;
+  URLs urls_to_delete;
   for (int32 i = g_test_count; i < g_test_count + kTestDeleteCount; i++) {
     GURL url(TestURL(i));
     master_->AddURL(url);
-    urls_to_delete.push_back(history::URLRow(url));
+    urls_to_delete.push_back(url);
   }
 
-  master_->DeleteURLs(urls_to_delete);
+  TestURLIterator iterator(urls_to_delete);
+  master_->DeleteURLs(&iterator);
   master_->DebugValidate();
 
   Reload();
 }
 
 TEST_F(VisitedLinkTest, DeleteAll) {
-  ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(0, true));
 
   {
     VisitedLinkSlave slave;
     base::SharedMemoryHandle new_handle = base::SharedMemory::NULLHandle();
     master_->shared_memory()->ShareToProcess(
         base::GetCurrentProcessHandle(), &new_handle);
     slave.OnUpdateVisitedLinks(new_handle);
     g_slaves.push_back(&slave);
 
@@ skipping 15 matching lines @@
       EXPECT_FALSE(master_->IsVisited(TestURL(i)));
       EXPECT_FALSE(slave.IsVisited(TestURL(i)));
     }
 
     // Close the database.
     g_slaves.clear();
     ClearDB();
   }
 
   // Reopen and validate.
-  ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(0, true));
   master_->DebugValidate();
   EXPECT_EQ(0, master_->GetUsedCount());
   for (int i = 0; i < g_test_count; i++)
     EXPECT_FALSE(master_->IsVisited(TestURL(i)));
 }
 
 // This tests that the master correctly resizes its tables when it gets too
 // full, notifies its slaves of the change, and updates the disk.
 TEST_F(VisitedLinkTest, Resizing) {
   // Create a very small database.
   const int32 initial_size = 17;
-  ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(initial_size, true));
 
   // ...and a slave
   VisitedLinkSlave slave;
   base::SharedMemoryHandle new_handle = base::SharedMemory::NULLHandle();
   master_->shared_memory()->ShareToProcess(
       base::GetCurrentProcessHandle(), &new_handle);
   slave.OnUpdateVisitedLinks(new_handle);
   g_slaves.push_back(&slave);
 
@@ skipping 28 matching lines @@
   master_->DebugValidate();
   g_slaves.clear();
 
   // This tests that the file is written correctly by reading it in using
   // a new database.
   Reload();
 }
 
 // Tests that if the database doesn't exist, it will be rebuilt from history.
 TEST_F(VisitedLinkTest, Rebuild) {
-  ASSERT_TRUE(InitHistory());
-
   // Add half of our URLs to history. This needs to be done before we
   // initialize the visited link DB.
   int history_count = g_test_count / 2;
   for (int i = 0; i < history_count; i++)
-    history_service_->AddPage(
-        TestURL(i), base::Time::Now(), history::SOURCE_BROWSED);
+    delegate_.AddURLForRebuild(TestURL(i));
 
   // Initialize the visited link DB. Since the visited links file doesn't exist
   // and we don't suppress history rebuilding, this will load from history.
   ASSERT_TRUE(InitVisited(0, false));
 
   // While the table is rebuilding, add the rest of the URLs to the visited
   // link system. This isn't guaranteed to happen during the rebuild, so we
   // can't be 100% sure we're testing the right thing, but in practice is.
   // All the adds above will generally take some time queuing up on the
   // history thread, and it will take a while to catch up to actually
   // processing the rebuild that has queued behind it. We will generally
   // finish adding all of the URLs before it has even found the first URL.
   for (int i = history_count; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
   // Add one more and then delete it.
   master_->AddURL(TestURL(g_test_count));
-  history::URLRows deleted_urls;
-  deleted_urls.push_back(history::URLRow(TestURL(g_test_count)));
-  master_->DeleteURLs(deleted_urls);
+  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(MessageLoop::QuitClosure());
   MessageLoop::current()->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(InitHistory());
   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(MessageLoop::QuitClosure());
   MessageLoop::current()->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(InitHistory());
   ASSERT_TRUE(InitVisited(0, true));
 
   // Add test URLs.
   for (int i = 0; i < g_test_count; i++) {
     master_->AddURL(TestURL(i));
     ASSERT_EQ(i + 1, master_->GetUsedCount());
   }
 
-  history::URLRows deleted_urls;
-  deleted_urls.push_back(history::URLRow(TestURL(0)));
   // Delete an URL.
-  master_->DeleteURLs(deleted_urls);
+  URLs urls_to_delete;
+  urls_to_delete.push_back(TestURL(0));
+  TestURLIterator iterator(urls_to_delete);
+  master_->DeleteURLs(&iterator);
+
   // ... and all of the remaining ones.
   master_->DeleteAllURLs();
 
   TrackingVisitedLinkEventListener* listener =
       static_cast<TrackingVisitedLinkEventListener*>(master_->GetListener());
 
   // Verify that VisitedLinkMaster::Listener::Add was called for each added URL.
   EXPECT_EQ(g_test_count, listener->add_count());
   // Verify that VisitedLinkMaster::Listener::Reset was called both when one and
   // all URLs are deleted.
   EXPECT_EQ(2, listener->reset_count());
 }
 
+// TODO(boliu): Inherit content::TestBrowserContext when componentized.
 class VisitCountingProfile : public TestingProfile {
  public:
   VisitCountingProfile()
       : add_count_(0),
         add_event_count_(0),
         reset_event_count_(0) {}
 
   void CountAddEvent(int by) {
     add_count_ += by;
     add_event_count_++;
@@ skipping 31 matching lines @@
         content::NotificationService::NoDetails());
   }
 
   virtual void WidgetRestored() OVERRIDE { widgets_++; }
   virtual void WidgetHidden() OVERRIDE { widgets_--; }
   virtual int VisibleWidgetCount() const OVERRIDE { return widgets_; }
 
   virtual bool Send(IPC::Message* msg) OVERRIDE {
     VisitCountingProfile* counting_profile =
         static_cast<VisitCountingProfile*>(
-            Profile::FromBrowserContext(GetBrowserContext()));
+            GetBrowserContext());
 
     if (msg->type() == ChromeViewMsg_VisitedLink_Add::ID) {
       PickleIterator iter(*msg);
       std::vector<uint64> fingerprints;
       CHECK(IPC::ReadParam(msg, &iter, &fingerprints));
       counting_profile->CountAddEvent(fingerprints.size());
     } else if (msg->type() == ChromeViewMsg_VisitedLink_Reset::ID) {
       counting_profile->CountResetEvent();
     }
 
@@ skipping 15 matching lines @@
   virtual content::RenderProcessHost* CreateRenderProcessHost(
       content::BrowserContext* browser_context) const OVERRIDE {
     return new VisitRelayingRenderProcessHost(browser_context);
   }
 
  private:
 
   DISALLOW_COPY_AND_ASSIGN(VisitedLinkRenderProcessHostFactory);
 };
 
+// TODO(boliu): Inherit content::RenderViewHostTestHarness when componentized.
 class VisitedLinkEventsTest : public ChromeRenderViewHostTestHarness {
  public:
   VisitedLinkEventsTest()
       : ui_thread_(BrowserThread::UI, &message_loop_),
         file_thread_(BrowserThread::FILE, &message_loop_) {}
   virtual ~VisitedLinkEventsTest() {}
   virtual void SetUp() {
     browser_context_.reset(new VisitCountingProfile());
-    profile()->CreateHistoryService(true, false);
-    master_ = static_cast<VisitedLinkMaster*>(
-        VisitedLinkMasterFactory::GetInstance()->
-            SetTestingFactoryAndUse(profile(), BuildVisitedLinkMaster));
+    master_.reset(new VisitedLinkMaster(profile(), &delegate_));
+    master_->Init();
     SetRenderProcessHostFactory(&vc_rph_factory_);
-    ChromeRenderViewHostTestHarness::SetUp();
+    content::RenderViewHostTestHarness::SetUp();
   }
 
   VisitCountingProfile* profile() const {
     return static_cast<VisitCountingProfile*>(browser_context_.get());
   }
 
   VisitedLinkMaster* master() const {
-    return master_;
+    return master_.get();
   }
 
   void WaitForCoalescense() {
     // Let the timer fire.
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         MessageLoop::QuitClosure(),
         base::TimeDelta::FromMilliseconds(110));
     MessageLoop::current()->Run();
   }
 
  protected:
   VisitedLinkRenderProcessHostFactory vc_rph_factory_;
 
  private:
-  VisitedLinkMaster* master_;
+  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/"));
@@ skipping 39 matching lines @@
 
   WaitForCoalescense();
 
   // We should have no change in results except for one new reset event.
   EXPECT_EQ(6, profile()->add_count());
   EXPECT_EQ(2, profile()->add_event_count());
   EXPECT_EQ(1, profile()->reset_event_count());
 }
 
 TEST_F(VisitedLinkEventsTest, Basics) {
-  rvh_tester()->CreateRenderView(string16(),
+  RenderViewHostTester::For(rvh())->CreateRenderView(string16(),
                                  MSG_ROUTING_NONE,
                                  -1);
 
   // Add a few URLs.
   master()->AddURL(GURL("http://acidtests.org/"));
   master()->AddURL(GURL("http://google.com/"));
   master()->AddURL(GURL("http://chromium.org/"));
 
   WaitForCoalescense();
 
   // We now should have 1 add event.
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(0, profile()->reset_event_count());
 
   master()->DeleteAllURLs();
 
   WaitForCoalescense();
 
   // We should have no change in add results, plus one new reset event.
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(1, profile()->reset_event_count());
 }
 
 TEST_F(VisitedLinkEventsTest, TabVisibility) {
-  rvh_tester()->CreateRenderView(string16(),
+  RenderViewHostTester::For(rvh())->CreateRenderView(string16(),
                                  MSG_ROUTING_NONE,
                                  -1);
 
   // Simulate tab becoming inactive.
-  rvh_tester()->SimulateWasHidden();
+  RenderViewHostTester::For(rvh())->SimulateWasHidden();
 
   // Add a few URLs.
   master()->AddURL(GURL("http://acidtests.org/"));
   master()->AddURL(GURL("http://google.com/"));
   master()->AddURL(GURL("http://chromium.org/"));
 
   WaitForCoalescense();
 
   // We shouldn't have any events.
   EXPECT_EQ(0, profile()->add_event_count());
   EXPECT_EQ(0, profile()->reset_event_count());
 
   // Simulate the tab becoming active.
-  rvh_tester()->SimulateWasShown();
+  RenderViewHostTester::For(rvh())->SimulateWasShown();
 
   // We should now have 3 add events, still no reset events.
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(0, profile()->reset_event_count());
 
   // Deactivate the tab again.
-  rvh_tester()->SimulateWasHidden();
+  RenderViewHostTester::For(rvh())->SimulateWasHidden();
 
   // Add a bunch of URLs (over 50) to exhaust the link event buffer.
   for (int i = 0; i < 100; i++)
     master()->AddURL(TestURL(i));
 
   WaitForCoalescense();
 
   // Again, no change in events until tab is active.
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(0, profile()->reset_event_count());
 
   // Activate the tab.
-  rvh_tester()->SimulateWasShown();
+  RenderViewHostTester::For(rvh())->SimulateWasShown();
 
   // We should have only one more reset event.
   EXPECT_EQ(1, profile()->add_event_count());
   EXPECT_EQ(1, profile()->reset_event_count());
 }