Load the table of visited links from database file asynchronously.

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/files/file_util.h"
 #include "base/location.h"
@@ skipping 89 matching lines @@
 bool TestURLIterator::HasNextURL() const {
   return iterator_ != end_;
 }
 
 }  // namespace
 
 class TrackingVisitedLinkEventListener : public VisitedLinkMaster::Listener {
  public:
   TrackingVisitedLinkEventListener()
       : reset_count_(0),
+        completely_reset_count_(0),
         add_count_(0) {}
 
   void NewTable(base::SharedMemory* table) override {
     if (table) {
       for (std::vector<VisitedLinkSlave>::size_type i = 0;
            i < g_slaves.size(); i++) {
         base::SharedMemoryHandle new_handle = base::SharedMemory::NULLHandle();
         table->ShareToProcess(base::GetCurrentProcessHandle(), &new_handle);
         g_slaves[i]->OnUpdateVisitedLinks(new_handle);
       }
     }
   }
   void Add(VisitedLinkCommon::Fingerprint) override { add_count_++; }
-  void Reset() override { reset_count_++; }
+  void Reset(bool invalidate_hashes) override {
+    if (invalidate_hashes)
+      completely_reset_count_++;
+    else
+      reset_count_++;
+  }
 
   void SetUp() {
     reset_count_ = 0;
     add_count_ = 0;
   }
 
   int reset_count() const { return reset_count_; }
+  int completely_reset_count() { return completely_reset_count_; }
   int add_count() const { return add_count_; }
 
  private:
   int reset_count_;
+  int completely_reset_count_;
   int add_count_;
 };
 
 class VisitedLinkTest : public testing::Test {
  protected:
   // 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) {
+  //
+  // |wait_for_io_complete| wait for result of async loading.
+  bool InitVisited(int initial_size,
+                   bool suppress_rebuild,
+                   bool wait_for_io_complete) {
     // Initialize the visited link system.
     master_.reset(new VisitedLinkMaster(new TrackingVisitedLinkEventListener(),
                                         &delegate_,
                                         true,
                                         suppress_rebuild, visited_file_,
                                         initial_size));
-    return master_->Init();
+    bool result = master_->Init();
+    if (result && wait_for_io_complete) {
+      // Wait for all pending file I/O to be completed.
+      content::RunAllBlockingPoolTasksUntilIdle();
+    }
+    return result;
   }
 
   // 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);
 
     // Wait for all pending file I/O to be completed.
     content::RunAllBlockingPoolTasksUntilIdle();
   }
 
   // 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(InitVisited(0, true));
+    ASSERT_TRUE(InitVisited(0, true, 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();
     master_->shared_memory()->ShareToProcess(
@@ skipping 41 matching lines @@
   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));
+  ASSERT_TRUE(InitVisited(0, true, 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(InitVisited(kInitialSize, true));
+  ASSERT_TRUE(InitVisited(kInitialSize, true, 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
   master_->AddFingerprint(kFingerprint1, false);  // @15
@@ skipping 17 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(InitVisited(16381, true));
+  ASSERT_TRUE(InitVisited(16381, true, 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;
   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(url);
   }
 
   TestURLIterator iterator(urls_to_delete);
   master_->DeleteURLs(&iterator);
   master_->DebugValidate();
 
   Reload();
 }
 
 TEST_F(VisitedLinkTest, DeleteAll) {
-  ASSERT_TRUE(InitVisited(0, true));
+  ASSERT_TRUE(InitVisited(0, true, 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);
 
     // Add the test URLs.
@@ skipping 14 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(InitVisited(0, true));
+  ASSERT_TRUE(InitVisited(0, true, 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(InitVisited(initial_size, true));
+  ASSERT_TRUE(InitVisited(initial_size, true, 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);
 
   int32 used_count = master_->GetUsedCount();
@@ skipping 35 matching lines @@
 // Tests that if the database doesn't exist, it will be rebuilt from history.
 TEST_F(VisitedLinkTest, Rebuild) {
   // 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++)
     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));
+  ASSERT_TRUE(InitVisited(0, false, 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));
@@ skipping 16 matching lines @@
 
   // 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));
+  ASSERT_TRUE(InitVisited(0, false, 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.
   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));
+  ASSERT_TRUE(InitVisited(0, true, true));
+
+  TrackingVisitedLinkEventListener* listener =
+      static_cast<TrackingVisitedLinkEventListener*>(master_->GetListener());
+
+  // Verify that VisitedLinkMaster::Listener::Reset(true) was never called when
+  // the table was created.
+  EXPECT_EQ(0, listener->completely_reset_count());
 
   // Add test URLs.
   for (int i = 0; i < g_test_count; i++) {
     master_->AddURL(TestURL(i));
     ASSERT_EQ(i + 1, master_->GetUsedCount());
   }
 
   // Delete an URL.
   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());
+
+  ClearDB();
+
+  ASSERT_TRUE(InitVisited(0, true, true));
+
+  listener =
+      static_cast<TrackingVisitedLinkEventListener*>(master_->GetListener());
+  // Verify that VisitedLinkMaster::Listener::Reset(true) was called when the
+  // table was loaded.
+  EXPECT_EQ(1, listener->completely_reset_count());
 }
 
 class VisitCountingContext : public content::TestBrowserContext {
  public:
   VisitCountingContext()
       : add_count_(0),
         add_event_count_(0),
         reset_event_count_(0),
+        completely_reset_event_count_(0),
         new_table_count_(0) {}
 
   void CountAddEvent(int by) {
     add_count_ += by;
     add_event_count_++;
   }
 
   void CountResetEvent() {
     reset_event_count_++;
   }
 
+  void CountCompletelyResetEvent() {
+    completely_reset_event_count_++;
+  }
+
   void CountNewTable() {
     new_table_count_++;
   }
 
   int add_count() const { return add_count_; }
   int add_event_count() const { return add_event_count_; }
   int reset_event_count() const { return reset_event_count_; }
+  int completely_reset_event_count() const {
+    return completely_reset_event_count_;
+  }
   int new_table_count() const { return new_table_count_; }
 
  private:
   int add_count_;
   int add_event_count_;
   int reset_event_count_;
+  int completely_reset_event_count_;
   int new_table_count_;
 };
 
 // Stub out as little as possible, borrowing from RenderProcessHost.
 class VisitRelayingRenderProcessHost : public MockRenderProcessHost {
  public:
   explicit VisitRelayingRenderProcessHost(
       content::BrowserContext* browser_context)
           : MockRenderProcessHost(browser_context), widgets_(0) {
     content::NotificationService::current()->Notify(
@@ skipping 16 matching lines @@
     VisitCountingContext* counting_context =
         static_cast<VisitCountingContext*>(
             GetBrowserContext());
 
     if (msg->type() == ChromeViewMsg_VisitedLink_Add::ID) {
       base::PickleIterator iter(*msg);
       std::vector<uint64> fingerprints;
       CHECK(IPC::ReadParam(msg, &iter, &fingerprints));
       counting_context->CountAddEvent(fingerprints.size());
     } else if (msg->type() == ChromeViewMsg_VisitedLink_Reset::ID) {
-      counting_context->CountResetEvent();
+      base::PickleIterator iter(*msg);
+      bool invalidate_hashes;
+      CHECK(IPC::ReadParam(msg, &iter, &invalidate_hashes));
+      if (invalidate_hashes)
+        counting_context->CountCompletelyResetEvent();
+      else
+        counting_context->CountResetEvent();
     } else if (msg->type() == ChromeViewMsg_VisitedLink_NewTable::ID) {
       counting_context->CountNewTable();
     }
 
     delete msg;
     return true;
   }
 
  private:
   int widgets_;
@@ skipping 28 matching lines @@
     // of teardown because it posts a task to close a file handle, and
     // we need to make sure we've finished all file related work
     // before our superclass sets about destroying the scoped temp
     // directory.
     master_.reset();
     RenderViewHostTestHarness::TearDown();
   }
 
   content::BrowserContext* CreateBrowserContext() override {
     VisitCountingContext* context = new VisitCountingContext();
-    master_.reset(new VisitedLinkMaster(context, &delegate_, true));
-    master_->Init();
+    CreateVisitedLinkMaster(context);
     return context;
   }
 
   VisitCountingContext* context() {
     return static_cast<VisitCountingContext*>(browser_context());
   }
 
   VisitedLinkMaster* master() const {
     return master_.get();
   }
 
   void WaitForCoalescence() {
     // Let the timer fire.
     //
     // TODO(ajwong): This is horrid! What is the right synchronization method?
     base::RunLoop run_loop;
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(),
         base::TimeDelta::FromMilliseconds(110));
     run_loop.Run();
   }
 
  protected:
+  void CreateVisitedLinkMaster(content::BrowserContext* browser_context) {
+    master_.reset(new VisitedLinkMaster(browser_context, &delegate_, true));
+    master_->Init();
+  }
+
   VisitedLinkRenderProcessHostFactory vc_rph_factory_;
 
- private:
   TestVisitedLinkDelegate delegate_;
   scoped_ptr<VisitedLinkMaster> master_;
 };
 
 TEST_F(VisitedLinkEventsTest, Coalescence) {
+  // Waiting complete rebuild the table.
+  content::RunAllBlockingPoolTasksUntilIdle();
+
+  WaitForCoalescence();
+
+  // After rebuild table expect reset event.
+  EXPECT_EQ(1, context()->reset_event_count());
+
   // 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/"));
 
   // Make sure that coalescing actually occurs. There should be no links or
   // events received by the renderer.
@@ skipping 28 matching lines @@
 
   // Ensure that the coalescing does not resume after resetting.
   master()->AddURL(GURL("http://build.chromium.org/"));
   master()->DeleteAllURLs();
 
   WaitForCoalescence();
 
   // We should have no change in results except for one new reset event.
   EXPECT_EQ(6, context()->add_count());
   EXPECT_EQ(2, context()->add_event_count());
-  EXPECT_EQ(1, context()->reset_event_count());
+  EXPECT_EQ(2, context()->reset_event_count());
 }
 
 TEST_F(VisitedLinkEventsTest, Basics) {
   RenderViewHostTester::For(rvh())->CreateTestRenderView(
       base::string16(), MSG_ROUTING_NONE, MSG_ROUTING_NONE, -1, false);
 
+  // Waiting complete rebuild the table.
+  content::RunAllBlockingPoolTasksUntilIdle();
+
+  WaitForCoalescence();
+
+  // After rebuild table expect reset event.
+  EXPECT_EQ(1, context()->reset_event_count());
+
   // Add a few URLs.
   master()->AddURL(GURL("http://acidtests.org/"));
   master()->AddURL(GURL("http://google.com/"));
   master()->AddURL(GURL("http://chromium.org/"));
 
   WaitForCoalescence();
 
   // We now should have 1 add event.
   EXPECT_EQ(1, context()->add_event_count());
-  EXPECT_EQ(0, context()->reset_event_count());
+  EXPECT_EQ(1, context()->reset_event_count());
 
   master()->DeleteAllURLs();
 
   WaitForCoalescence();
 
   // We should have no change in add results, plus one new reset event.
   EXPECT_EQ(1, context()->add_event_count());
-  EXPECT_EQ(1, context()->reset_event_count());
+  EXPECT_EQ(2, context()->reset_event_count());
 }
 
 TEST_F(VisitedLinkEventsTest, TabVisibility) {
   RenderViewHostTester::For(rvh())->CreateTestRenderView(
       base::string16(), MSG_ROUTING_NONE, MSG_ROUTING_NONE, -1, false);
 
+  // Waiting complete rebuild the table.
+  content::RunAllBlockingPoolTasksUntilIdle();
+
+  WaitForCoalescence();
+
+  // After rebuild table expect reset event.
+  EXPECT_EQ(1, context()->reset_event_count());
+
   // Simulate tab becoming inactive.
   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/"));
 
   WaitForCoalescence();
 
   // We shouldn't have any events.
   EXPECT_EQ(0, context()->add_event_count());
-  EXPECT_EQ(0, context()->reset_event_count());
+  EXPECT_EQ(1, context()->reset_event_count());
 
   // Simulate the tab becoming active.
   RenderViewHostTester::For(rvh())->SimulateWasShown();
 
   // We should now have 3 add events, still no reset events.
   EXPECT_EQ(1, context()->add_event_count());
-  EXPECT_EQ(0, context()->reset_event_count());
+  EXPECT_EQ(1, context()->reset_event_count());
 
   // Deactivate the tab again.
   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));
 
   WaitForCoalescence();
 
   // Again, no change in events until tab is active.
   EXPECT_EQ(1, context()->add_event_count());
-  EXPECT_EQ(0, context()->reset_event_count());
+  EXPECT_EQ(1, context()->reset_event_count());
 
   // Activate the tab.
   RenderViewHostTester::For(rvh())->SimulateWasShown();
 
   // We should have only one more reset event.
   EXPECT_EQ(1, context()->add_event_count());
-  EXPECT_EQ(1, context()->reset_event_count());
+  EXPECT_EQ(2, context()->reset_event_count());
 }
 
 // Tests that VisitedLink ignores renderer process creation notification for a
 // different context.
 TEST_F(VisitedLinkEventsTest, IgnoreRendererCreationFromDifferentContext) {
   VisitCountingContext different_context;
   VisitRelayingRenderProcessHost different_process_host(&different_context);
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_RENDERER_PROCESS_CREATED,
       content::Source<content::RenderProcessHost>(&different_process_host),
       content::NotificationService::NoDetails());
   WaitForCoalescence();
 
   EXPECT_EQ(0, different_context.new_table_count());
 }
 
+class VisitedLinkCompletelyResetEventTest : public VisitedLinkEventsTest {
+ public:
+  content::BrowserContext* CreateBrowserContext() override {
+    VisitCountingContext* context = new VisitCountingContext();
+    CreateVisitedLinkFile(context);
+    CreateVisitedLinkMaster(context);
+    return context;
+  }
+
+  void CreateVisitedLinkFile(content::BrowserContext* browser_context) {
+    base::FilePath visited_file =
+        browser_context->GetPath().Append(FILE_PATH_LITERAL("Visited Links"));
+    scoped_ptr<VisitedLinkMaster> master(
+        new VisitedLinkMaster(new TrackingVisitedLinkEventListener(),
+                              &delegate_, true, true, visited_file, 0));
+    master->Init();
+    // Waiting complete create the table.
+    content::RunAllBlockingPoolTasksUntilIdle();
+
+    master.reset();
+    // Wait for all pending file I/O to be completed.
+    content::RunAllBlockingPoolTasksUntilIdle();
+  }
+};
+
+TEST_F(VisitedLinkCompletelyResetEventTest, LoadTable) {
+  // Waiting complete loading the table.
+  content::RunAllBlockingPoolTasksUntilIdle();
+
+  WaitForCoalescence();
+
+  // After load table expect completely reset event.
+  EXPECT_EQ(1, context()->completely_reset_event_count());
+}
+
 }  // namespace visitedlink