Move InMemoryURLIndex Caching Operations to FILE Thread

chrome/browser/history/in_memory_url_index_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 <fstream>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/message_loop.h"
 #include "base/path_service.h"
+#include "base/scoped_temp_dir.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/in_memory_url_index.h"
 #include "chrome/browser/history/in_memory_url_index_types.h"
+#include "chrome/browser/history/url_index_private_data.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/test/test_browser_thread.h"
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using content::BrowserThread;
+
 // The test version of the history url database table ('url') is contained in
 // a database file created from a text file('url_history_provider_test.db.txt').
 // The only difference between this table and a live 'urls' table from a
 // profile is that the last_visit_time column in the test table contains a
 // number specifying the number of days relative to 'today' to which the
 // absolute time should be set during the test setup stage.
 //
 // The format of the test database text file is of a SQLite .dump file.
 // Note that only lines whose first character is an upper-case letter are
 // processed when creating the test database.
 
 namespace history {
 
+// -----------------------------------------------------------------------------
+
+// Observer class so the unit tests can wait while the cache is being saved.
+class CacheFileSaverObserver : public InMemoryURLIndex::SaveCacheObserver {
+ public:
+  explicit CacheFileSaverObserver(MessageLoop* loop)

[Peter Kasting, 2012/01/14 00:12:49]

Nit: I know it's just a test file, but I'd prefer not to inline constructors or
virtual functions all the same.

[mrossetti, 2012/03/03 05:05:56]

Will do in the next CL.

+      : loop_(loop),
+        succeeded_(false) {
+    DCHECK(loop);
+  }
+
+  virtual void OnCacheSaveFinished() OVERRIDE {
+    succeeded_ = true;
+    loop_->Quit();
+  }
+  virtual void OnCacheSaveFailed() OVERRIDE { loop_->Quit(); }
+
+ private:
+  MessageLoop* loop_;
+  bool succeeded_;
+  DISALLOW_COPY_AND_ASSIGN(CacheFileSaverObserver);
+};
+
+// Observer class so the unit tests can wait while the cache is being restored.
+class CacheFileReaderObserver : public InMemoryURLIndex::RestoreCacheObserver {
+ public:
+  explicit CacheFileReaderObserver(MessageLoop* loop)
+      : loop_(loop),
+        succeeded_(false) {
+    DCHECK(loop);
+  }
+
+  virtual void OnCacheRestoreFinished(bool succeeded) OVERRIDE {
+    succeeded_ = succeeded;
+    loop_->Quit();
+  }
+
+ private:
+  MessageLoop* loop_;
+  bool succeeded_;
+  DISALLOW_COPY_AND_ASSIGN(CacheFileReaderObserver);
+};
+
+// -----------------------------------------------------------------------------
+
 class InMemoryURLIndexTest : public testing::Test,
                              public InMemoryDatabase {
  public:
   InMemoryURLIndexTest() { InitFromScratch(); }
 
  protected:
   // Test setup.
   virtual void SetUp();
 
   // Allows the database containing the test data to be customized by
@@ skipping 11 matching lines @@
 
   // Convenience functions for easily creating vectors of search terms.
   String16Vector Make1Term(const char* term) const;
   String16Vector Make2Terms(const char* term_1, const char* term_2) const;
 
   // Validates that the given |term| is contained in |cache| and that it is
   // marked as in-use.
   void CheckTerm(const URLIndexPrivateData::SearchTermCacheMap& cache,
                  string16 term) const;
 
-  scoped_ptr<InMemoryURLIndex> url_index_;
+  scoped_ptr<TestingProfile> profile_;
+  scoped_refptr<InMemoryURLIndex> url_index_;
 };
 
 void InMemoryURLIndexTest::SetUp() {
+  profile_.reset(new TestingProfile());
+
   // Create and populate a working copy of the URL history database.
   FilePath history_proto_path;
   PathService::Get(chrome::DIR_TEST_DATA, &history_proto_path);
   history_proto_path = history_proto_path.Append(
       FILE_PATH_LITERAL("History"));
   history_proto_path = history_proto_path.Append(TestDBName());
   EXPECT_TRUE(file_util::PathExists(history_proto_path));
 
   std::ifstream proto_file(history_proto_path.value().c_str());
   static const size_t kCommandBufferMaxSize = 2048;
@@ skipping 109 matching lines @@
 
 class LimitedInMemoryURLIndexTest : public InMemoryURLIndexTest {
  protected:
   FilePath::StringType TestDBName() const;
 };
 
 FilePath::StringType LimitedInMemoryURLIndexTest::TestDBName() const {
   return FILE_PATH_LITERAL("url_history_provider_test_limited.db.txt");
 }
 
-TEST_F(InMemoryURLIndexTest, Construction) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  EXPECT_TRUE(url_index_.get());
-}
-
 TEST_F(LimitedInMemoryURLIndexTest, Initialization) {
   // Verify that the database contains the expected number of items, which
   // is the pre-filtered count, i.e. all of the items.
   sql::Statement statement(GetDB().GetUniqueStatement("SELECT * FROM urls;"));
   EXPECT_TRUE(statement);
   uint64 row_count = 0;
   while (statement.Step()) ++row_count;
   EXPECT_EQ(1U, row_count);
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
   URLIndexPrivateData& private_data(*(url_index_->private_data_));
 
   // history_info_map_ should have the same number of items as were filtered.
   EXPECT_EQ(1U, private_data.history_info_map_.size());
   EXPECT_EQ(35U, private_data.char_word_map_.size());
   EXPECT_EQ(17U, private_data.word_map_.size());
 }
 
+//------------------------------------------------------------------------------
+
+TEST_F(InMemoryURLIndexTest, Construction) {
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  EXPECT_TRUE(url_index_.get());
+}
+
 TEST_F(InMemoryURLIndexTest, Retrieval) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
   // The term will be lowercased by the search.
 
   // See if a very specific term gives a single result.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudgeReport"));
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   EXPECT_EQ(5, matches[0].url_info.id());
   EXPECT_EQ("http://drudgereport.com/", matches[0].url_info.url().spec());
@@ skipping 27 matching lines @@
             matches[0].url_info.url().spec());  // Note: URL gets lowercased.
   EXPECT_EQ(ASCIIToUTF16("Practically Useless Search Result"),
             matches[0].url_info.title());
 
   // Search which will match at the end of an URL with encoded characters.
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("ice"));
   ASSERT_EQ(1U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, ProperStringMatching) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
 
   // Search for the following with the expected results:
   // "atdmt view" - found
   // "atdmt.view" - not found
   // "view.atdmt" - found
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("atdmt view"));
   ASSERT_EQ(1U, matches.size());
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("atdmt.view"));
   ASSERT_EQ(0U, matches.size());
   matches = url_index_->HistoryItemsForTerms(ASCIIToUTF16("view.atdmt"));
   ASSERT_EQ(1U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, HugeResultSet) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
 
   // Create a huge set of qualifying history items.
   for (URLID row_id = 5000; row_id < 6000; ++row_id) {
     URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), row_id);
     new_row.set_last_visit(base::Time::Now());
-    url_index_->UpdateURL(row_id, new_row);
+    url_index_->UpdateURL(new_row);
   }
 
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("b"));
   ASSERT_EQ(AutocompleteProvider::kMaxMatches, matches.size());
   // There are 7 matches already in the database.
   URLIndexPrivateData& private_data(*(url_index_->private_data_.get()));
   ASSERT_EQ(1007U, private_data.pre_filter_item_count_);
   ASSERT_EQ(500U, private_data.post_filter_item_count_);
   ASSERT_EQ(AutocompleteProvider::kMaxMatches,
             private_data.post_scoring_item_count_);
 }
 
 TEST_F(InMemoryURLIndexTest, TitleSearch) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
   // Signal if someone has changed the test DB.
   EXPECT_EQ(27U, url_index_->private_data_->history_info_map_.size());
 
   // Ensure title is being searched.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("MORTGAGE RATE DROPS"));
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   EXPECT_EQ(1, matches[0].url_info.id());
   EXPECT_EQ("http://www.reuters.com/article/idUSN0839880620100708",
             matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16(
       "UPDATE 1-US 30-yr mortgage rate drops to new record low | Reuters"),
       matches[0].url_info.title());
 }
 
 TEST_F(InMemoryURLIndexTest, TitleChange) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
 
   // Verify current title terms retrieves desired item.
   string16 original_terms =
       ASCIIToUTF16("lebronomics could high taxes influence");
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(original_terms);
   ASSERT_EQ(1U, matches.size());
 
   // Verify that we got back the result we expected.
   const URLID expected_id = 3;
   EXPECT_EQ(expected_id, matches[0].url_info.id());
   EXPECT_EQ("http://www.businessandmedia.org/articles/2010/20100708120415.aspx",
             matches[0].url_info.url().spec());
   EXPECT_EQ(ASCIIToUTF16(
       "LeBronomics: Could High Taxes Influence James' Team Decision?"),
       matches[0].url_info.title());
   URLRow old_row(matches[0].url_info);
 
   // Verify new title terms retrieves nothing.
   string16 new_terms = ASCIIToUTF16("does eat oats little lambs ivy");
   matches = url_index_->HistoryItemsForTerms(new_terms);
   ASSERT_EQ(0U, matches.size());
 
   // Update the row.
   old_row.set_title(ASCIIToUTF16("Does eat oats and little lambs eat ivy"));
-  url_index_->UpdateURL(expected_id, old_row);
+  url_index_->UpdateURL(old_row);
 
   // Verify we get the row using the new terms but not the original terms.
   matches = url_index_->HistoryItemsForTerms(new_terms);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(expected_id, matches[0].url_info.id());
   matches = url_index_->HistoryItemsForTerms(original_terms);
   ASSERT_EQ(0U, matches.size());
 }
 
 TEST_F(InMemoryURLIndexTest, NonUniqueTermCharacterSets) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
 
   // The presence of duplicate characters should succeed. Exercise by cycling
   // through a string with several duplicate characters.
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("ABRA"));
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(28, matches[0].url_info.id());
   EXPECT_EQ("http://www.ddj.com/windows/184416623",
             matches[0].url_info.url().spec());
 
@@ skipping 14 matching lines @@
   EXPECT_EQ(28, matches[0].url_info.id());
 }
 
 TEST_F(InMemoryURLIndexTest, TypedCharacterCaching) {
   // Verify that match results for previously typed characters are retained
   // (in the term_char_word_set_cache_) and reused, if possible, in future
   // autocompletes.
   typedef URLIndexPrivateData::SearchTermCacheMap::iterator CacheIter;
   typedef URLIndexPrivateData::SearchTermCacheItem CacheItem;
 
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
 
   URLIndexPrivateData::SearchTermCacheMap& cache(
       url_index_->private_data_->search_term_cache_);
 
   // The cache should be empty at this point.
   EXPECT_EQ(0U, cache.size());
 
   // Now simulate typing search terms into the omnibox and check the state of
   // the cache as each item is 'typed'.
 
@@ skipping 66 matching lines @@
       URLIndexPrivateData::ScoredMatchForURL(row_c, Make1Term("abc")));
   EXPECT_GT(scored_g.raw_score, scored_a.raw_score);
   // Test scores based on typed_count.
   URLRow row_d(MakeURLRow("http://abcdef", "fedcba", 3, 30, 10));
   ScoredHistoryMatch scored_h(
       URLIndexPrivateData::ScoredMatchForURL(row_d, Make1Term("abc")));
   EXPECT_GT(scored_h.raw_score, scored_a.raw_score);
 }
 
 TEST_F(InMemoryURLIndexTest, AddNewRows) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
 
   // Verify that the row we're going to add does not already exist.
   URLID new_row_id = 87654321;
   // Newly created URLRows get a last_visit time of 'right now' so it should
   // qualify as a quick result candidate.
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("brokeandalone")).empty());
 
   // Add a new row.
   URLRow new_row(GURL("http://www.brokeandaloneinmanitoba.com/"), new_row_id);
+  new_row.set_title(ASCIIToUTF16("Timothy Little and His Amazing Dog Boo"));
   new_row.set_last_visit(base::Time::Now());
-  url_index_->UpdateURL(new_row_id, new_row);
+  url_index_->UpdateURL(new_row);
 
   // Verify that we can retrieve it.
   EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("brokeandalone")).size());
 
+  // Verify that we can retrieve it by title.
+  EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(
+      ASCIIToUTF16("Timothy Little")).size());
+
   // Add it again just to be sure that is harmless.
-  url_index_->UpdateURL(new_row_id, new_row);
+  url_index_->UpdateURL(new_row);
   EXPECT_EQ(1U, url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("brokeandalone")).size());
 }
 
 TEST_F(InMemoryURLIndexTest, DeleteRows) {
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
-  url_index_->Init(this, "en,ja,hi,zh");
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
+  url_index_->Init("en,ja,hi,zh");
+  url_index_->RebuildFromHistory(this);
 
   ScoredHistoryMatches matches =
       url_index_->HistoryItemsForTerms(ASCIIToUTF16("DrudgeReport"));
   ASSERT_EQ(1U, matches.size());
 
   // Determine the row id for that result, delete that id, then search again.
-  url_index_->DeleteURL(matches[0].url_info.id());
+  url_index_->DeleteURL(matches[0].url_info.url());
   EXPECT_TRUE(url_index_->HistoryItemsForTerms(
       ASCIIToUTF16("DrudgeReport")).empty());
 }
 
 TEST_F(InMemoryURLIndexTest, WhitelistedURLs) {
   struct TestData {
     const std::string url_spec;
     const bool expected_is_whitelisted;
   } data[] = {
     // URLs with whitelisted schemes.
@@ skipping 57 matching lines @@
     { "telnet://mayor_margie:one2rule4All@www.mycity.com:6789/", false },
     { "tftp://example.com/mystartupfile", false },
     { "tip://123.123.123.123/?urn:xopen:xid", false },
     { "tv:nbc.com", false },
     { "urn:foo:A123,456", false },
     { "vemmi://zeus.mctel.fr/demo", false },
     { "wais://www.mydomain.net:8765/mydatabase", false },
     { "xmpp:node@example.com", false },
     { "xmpp://guest@example.com", false },
   };
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
   URLIndexPrivateData& private_data(*(url_index_->private_data_.get()));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     GURL url(data[i].url_spec);
     EXPECT_EQ(data[i].expected_is_whitelisted,
               private_data.URLSchemeIsWhitelisted(url));
   }
 }
 
 TEST_F(InMemoryURLIndexTest, CacheFilePath) {
-  url_index_.reset(new InMemoryURLIndex(FilePath(FILE_PATH_LITERAL(
-      "/flammmy/frammy/"))));
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath(FILE_PATH_LITERAL(
+      "/flammmy/frammy/")));
   FilePath full_file_path;
   url_index_->GetCacheFilePath(&full_file_path);
   std::vector<FilePath::StringType> expected_parts;
   FilePath(FILE_PATH_LITERAL("/flammmy/frammy/History Provider Cache")).
       GetComponents(&expected_parts);
   std::vector<FilePath::StringType> actual_parts;
   full_file_path.GetComponents(&actual_parts);
   ASSERT_EQ(expected_parts.size(), actual_parts.size());
   size_t count = expected_parts.size();
   for (size_t i = 0; i < count; ++i)
     EXPECT_EQ(expected_parts[i], actual_parts[i]);
   // Must clear the history_dir_ to satisfy the dtor's DCHECK.
   url_index_->history_dir_.clear();
 }
 
 TEST_F(InMemoryURLIndexTest, CacheSaveRestore) {
+  MessageLoop message_loop;
+  content::TestBrowserThread fake_ui_thread(BrowserThread::UI, &message_loop);
+  content::TestBrowserThread fake_file_thread(BrowserThread::FILE,
+                                              &message_loop);
+
   // Save the cache to a protobuf, restore it, and compare the results.
-  url_index_.reset(new InMemoryURLIndex(FilePath()));
+  url_index_ = new InMemoryURLIndex(profile_.get(), FilePath());
   InMemoryURLIndex& url_index(*(url_index_.get()));
-  url_index.Init(this, "en,ja,hi,zh");
-  in_memory_url_index::InMemoryURLIndexCacheItem index_cache;
-  URLIndexPrivateData& private_data(*(url_index_->private_data_.get()));
-  private_data.SavePrivateData(&index_cache);
+  url_index.Init("en,ja,hi,zh");
+  url_index.RebuildFromHistory(this);
 
-  // Capture our private data so we can later compare for equality.
-  String16Vector word_list(private_data.word_list_);
-  WordMap word_map(private_data.word_map_);
-  CharWordIDMap char_word_map(private_data.char_word_map_);
-  WordIDHistoryMap word_id_history_map(private_data.word_id_history_map_);
-  HistoryIDWordMap history_id_word_map(private_data.history_id_word_map_);
-  HistoryInfoMap history_info_map(private_data.history_info_map_);
+  URLIndexPrivateData& private_data(*(url_index_->private_data_));
 
-  // Prove that there is really something there.
+  // Ensure that there is really something there to be saved.
   EXPECT_FALSE(private_data.word_list_.empty());
   // available_words_ will already be empty since we have freshly built the
   // data set for this test.
   EXPECT_TRUE(private_data.available_words_.empty());
   EXPECT_FALSE(private_data.word_map_.empty());
   EXPECT_FALSE(private_data.char_word_map_.empty());
   EXPECT_FALSE(private_data.word_id_history_map_.empty());
   EXPECT_FALSE(private_data.history_id_word_map_.empty());
   EXPECT_FALSE(private_data.history_info_map_.empty());
 
-  // Clear and then prove it's clear.
-  private_data.Clear();
+  // Capture the current private data for later comparison to restored data.
+  URLIndexPrivateData old_data(*(url_index_->private_data_));
+
+  // Save then restore our private data.
+  ScopedTempDir temp_directory;
+  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
+  FilePath temp_file;
+  ASSERT_TRUE(file_util::CreateTemporaryFileInDir(temp_directory.path(),
+                                                  &temp_file));
+  CacheFileSaverObserver save_observer(&message_loop);
+  url_index_->set_save_cache_observer(&save_observer);
+  url_index.DoSaveToCacheFile(temp_file);
+  message_loop.Run();
+
+  // Clear and then prove it's clear before restoring.
+  url_index.ClearPrivateData();
   EXPECT_TRUE(private_data.word_list_.empty());
   EXPECT_TRUE(private_data.available_words_.empty());
   EXPECT_TRUE(private_data.word_map_.empty());
   EXPECT_TRUE(private_data.char_word_map_.empty());
   EXPECT_TRUE(private_data.word_id_history_map_.empty());
   EXPECT_TRUE(private_data.history_id_word_map_.empty());
   EXPECT_TRUE(private_data.history_info_map_.empty());
 
-  // Restore the cache.
-  EXPECT_TRUE(private_data.RestorePrivateData(index_cache));
+  CacheFileReaderObserver read_observer(&message_loop);
+  url_index_->set_restore_cache_observer(&read_observer);
+  url_index.DoRestoreFromCacheFile(temp_file);
+  message_loop.Run();
 
-  // Compare the restored and captured for equality.
-  EXPECT_EQ(word_list.size(), private_data.word_list_.size());
-  EXPECT_EQ(word_map.size(), private_data.word_map_.size());
-  EXPECT_EQ(char_word_map.size(), private_data.char_word_map_.size());
-  EXPECT_EQ(word_id_history_map.size(),
-            private_data.word_id_history_map_.size());
-  EXPECT_EQ(history_id_word_map.size(),
-            private_data.history_id_word_map_.size());
-  EXPECT_EQ(history_info_map.size(), private_data.history_info_map_.size());
+  URLIndexPrivateData& new_data(*(url_index_->private_data_));
+
+  // Compare the captured and restored for equality.
+  EXPECT_EQ(old_data.word_list_.size(), new_data.word_list_.size());
+  EXPECT_EQ(old_data.word_map_.size(), new_data.word_map_.size());
+  EXPECT_EQ(old_data.char_word_map_.size(), new_data.char_word_map_.size());
+  EXPECT_EQ(old_data.word_id_history_map_.size(),
+            new_data.word_id_history_map_.size());
+  EXPECT_EQ(old_data.history_id_word_map_.size(),
+            new_data.history_id_word_map_.size());
+  EXPECT_EQ(old_data.history_info_map_.size(),
+            new_data.history_info_map_.size());
   // WordList must be index-by-index equal.
-  size_t count = word_list.size();
+  size_t count = old_data.word_list_.size();
   for (size_t i = 0; i < count; ++i)
-    EXPECT_EQ(word_list[i], private_data.word_list_[i]);
+    EXPECT_EQ(old_data.word_list_[i], new_data.word_list_[i]);
 
-  ExpectMapOfContainersIdentical(char_word_map,
-                                 private_data.char_word_map_);
-  ExpectMapOfContainersIdentical(word_id_history_map,
-                                 private_data.word_id_history_map_);
-  ExpectMapOfContainersIdentical(history_id_word_map,
-                                 private_data.history_id_word_map_);
+  ExpectMapOfContainersIdentical(old_data.char_word_map_,
+                                 new_data.char_word_map_);
+  ExpectMapOfContainersIdentical(old_data.word_id_history_map_,
+                                 new_data.word_id_history_map_);
+  ExpectMapOfContainersIdentical(old_data.history_id_word_map_,
+                                 new_data.history_id_word_map_);
 
-  for (HistoryInfoMap::const_iterator expected = history_info_map.begin();
-       expected != history_info_map.end(); ++expected) {
+  for (HistoryInfoMap::const_iterator expected =
+       old_data.history_info_map_.begin();
+       expected != old_data.history_info_map_.end(); ++expected) {
     HistoryInfoMap::const_iterator actual =
-        private_data.history_info_map_.find(expected->first);
-    ASSERT_FALSE(private_data.history_info_map_.end() == actual);
+        new_data.history_info_map_.find(expected->first);
+    ASSERT_FALSE(new_data.history_info_map_.end() == actual);
     const URLRow& expected_row(expected->second);
     const URLRow& actual_row(actual->second);
     EXPECT_EQ(expected_row.visit_count(), actual_row.visit_count());
     EXPECT_EQ(expected_row.typed_count(), actual_row.typed_count());
     EXPECT_EQ(expected_row.last_visit(), actual_row.last_visit());
     EXPECT_EQ(expected_row.url(), actual_row.url());
   }
 }
 
 }  // namespace history