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 <algorithm>
 #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/string_util.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_backend.h"
 #include "chrome/browser/history/history_database.h"
 #include "chrome/browser/history/in_memory_url_index_types.h"
 #include "chrome/browser/history/in_memory_url_index.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);
+  virtual void OnCacheSaveFinished(bool succeeded) OVERRIDE;
+
+  MessageLoop* loop_;
+  bool succeeded_;
+  DISALLOW_COPY_AND_ASSIGN(CacheFileSaverObserver);
+};
+
+CacheFileSaverObserver::CacheFileSaverObserver(MessageLoop* loop)
+    : loop_(loop),
+      succeeded_(false) {
+  DCHECK(loop);
+}
+
+void CacheFileSaverObserver::OnCacheSaveFinished(bool succeeded) {
+  succeeded_ = succeeded;
+  loop_->Quit();
+}
+
+// Observer class so the unit tests can wait while the cache is being restored.
+class CacheFileReaderObserver : public InMemoryURLIndex::RestoreCacheObserver {
+ public:
+  explicit CacheFileReaderObserver(MessageLoop* loop);
+  virtual void OnCacheRestoreFinished(bool succeeded) OVERRIDE;
+
+  MessageLoop* loop_;
+  bool succeeded_;
+  DISALLOW_COPY_AND_ASSIGN(CacheFileReaderObserver);
+};
+
+CacheFileReaderObserver::CacheFileReaderObserver(MessageLoop* loop)
+    : loop_(loop),
+      succeeded_(false) {
+  DCHECK(loop);
+}
+
+void CacheFileReaderObserver::OnCacheRestoreFinished(bool succeeded) {
+  succeeded_ = succeeded;
+  loop_->Quit();
+}
+
+// -----------------------------------------------------------------------------
+
 class InMemoryURLIndexTest : public testing::Test {
  public:
   InMemoryURLIndexTest();
 
  protected:
   // Test setup.
   virtual void SetUp();
 
   // Allows the database containing the test data to be customized by
   // subclasses.
@@ skipping 15 matching lines @@
   // 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;
 
   // Pass-through function to simplify our friendship with HistoryService.
   sql::Connection& GetDB();
 
   // Pass-through functions to simplify our friendship with InMemoryURLIndex.
   URLIndexPrivateData* GetPrivateData() const;
+  void ClearPrivateData();
+  void set_history_dir(const FilePath& dir_path);
   bool GetCacheFilePath(FilePath* file_path) const;
-  void ClearHistoryDir() const;
+  void PostRestoreFromCacheFileTask();
+  void PostSaveToCacheFileTask();
+  const std::set<std::string>& scheme_whitelist();
+
 
   // Pass-through functions to simplify our friendship with URLIndexPrivateData.
   bool UpdateURL(const URLRow& row);
   bool DeleteURL(const GURL& url);
 
   // Data verification helper functions.
   void ExpectPrivateDataNotEmpty(const URLIndexPrivateData& data);
   void ExpectPrivateDataEmpty(const URLIndexPrivateData& data);
   void ExpectPrivateDataEqual(const URLIndexPrivateData& expected,
                               const URLIndexPrivateData& actual);
@@ skipping 10 matching lines @@
 InMemoryURLIndexTest::InMemoryURLIndexTest()
     : ui_thread_(content::BrowserThread::UI, &message_loop_),
       file_thread_(content::BrowserThread::FILE, &message_loop_) {
 }
 
 sql::Connection& InMemoryURLIndexTest::GetDB() {
   return history_database_->GetDB();
 }
 
 URLIndexPrivateData* InMemoryURLIndexTest::GetPrivateData() const {
-  DCHECK(url_index_->private_data_.get());
-  return url_index_->private_data_.get();
+  DCHECK(url_index_->private_data());
+  return url_index_->private_data();
+}
+
+void InMemoryURLIndexTest::ClearPrivateData() {
+  return url_index_->ClearPrivateData();
+}
+
+void InMemoryURLIndexTest::set_history_dir(const FilePath& dir_path) {
+  return url_index_->set_history_dir(dir_path);
 }
 
 bool InMemoryURLIndexTest::GetCacheFilePath(FilePath* file_path) const {
   DCHECK(file_path);
   return url_index_->GetCacheFilePath(file_path);
 }
 
-void InMemoryURLIndexTest::ClearHistoryDir() const {
-  url_index_->history_dir_.clear();
+void InMemoryURLIndexTest::PostRestoreFromCacheFileTask() {
+  url_index_->PostRestoreFromCacheFileTask();
+}
+
+void InMemoryURLIndexTest::PostSaveToCacheFileTask() {
+  url_index_->PostSaveToCacheFileTask();
+}
+
+const std::set<std::string>& InMemoryURLIndexTest::scheme_whitelist() {
+  return url_index_->scheme_whitelist();
 }
 
 bool InMemoryURLIndexTest::UpdateURL(const URLRow& row) {
-  return url_index_->private_data_->UpdateURL(row);
+  return GetPrivateData()->UpdateURL(row, url_index_->languages_,
+                                     url_index_->scheme_whitelist_);
 }
 
 bool InMemoryURLIndexTest::DeleteURL(const GURL& url) {
-  return url_index_->private_data_->DeleteURL(url);
+  return GetPrivateData()->DeleteURL(url);
 }
 
 void InMemoryURLIndexTest::SetUp() {
   // We cannot access the database until the backend has been loaded.
   profile_.CreateHistoryService(true, false);
   profile_.CreateBookmarkModel(true);
   profile_.BlockUntilBookmarkModelLoaded();
   profile_.BlockUntilHistoryProcessesPendingRequests();
   HistoryService* history_service =
       profile_.GetHistoryService(Profile::EXPLICIT_ACCESS);
@@ skipping 215 matching lines @@
   FilePath::StringType TestDBName() const;
 };
 
 FilePath::StringType LimitedInMemoryURLIndexTest::TestDBName() const {
   return FILE_PATH_LITERAL("url_history_provider_test_limited.db.txt");
 }
 
 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::Connection& db(GetDB());
-  sql::Statement statement(db.GetUniqueStatement("SELECT * FROM urls;"));
+  sql::Statement statement(GetDB().GetUniqueStatement("SELECT * FROM urls;"));
   ASSERT_TRUE(statement.is_valid());
   uint64 row_count = 0;
   while (statement.Step()) ++row_count;
   EXPECT_EQ(1U, row_count);
   url_index_.reset(
       new InMemoryURLIndex(&profile_, FilePath(), "en,ja,hi,zh"));
   url_index_->Init();
   url_index_->RebuildFromHistory(history_database_);
-  URLIndexPrivateData& private_data(*(url_index_->private_data_));
+  URLIndexPrivateData& private_data(*GetPrivateData());
 
   // 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, Retrieval) {
   // See if a very specific term gives a single result.
   ScoredHistoryMatches matches =
@@ skipping 448 matching lines @@
     { "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 },
   };
 
   URLIndexPrivateData& private_data(*GetPrivateData());
+  const std::set<std::string>& whitelist(scheme_whitelist());
   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));
+              private_data.URLSchemeIsWhitelisted(url, whitelist));
   }
 }
 
 TEST_F(InMemoryURLIndexTest, CacheSaveRestore) {
-  // Part 1: Save the cache to a protobuf, restore it, and compare the results.
-  in_memory_url_index::InMemoryURLIndexCacheItem index_cache;
-  URLIndexPrivateData& expected(*GetPrivateData());
+  ScopedTempDir temp_directory;
+  ASSERT_TRUE(temp_directory.CreateUniqueTempDir());
+  set_history_dir(temp_directory.path());
 
-  // Capture our private data so we can later compare for equality.
-  URLIndexPrivateData actual(expected);
+  URLIndexPrivateData& private_data(*GetPrivateData());
 
-  actual.SavePrivateData(&index_cache);
+  // 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());
 
-  // Version check: Make sure this version actually has the word starts.
-  EXPECT_TRUE(index_cache.has_word_starts_map());
+  // Capture the current private data for later comparison to restored data.
+  scoped_refptr<URLIndexPrivateData> old_data(private_data.Duplicate());
 
-  // Save the size of the resulting cache for later versioning comparison.
-  std::string data;
-  EXPECT_TRUE(index_cache.SerializeToString(&data));
-  size_t current_version_cache_size = data.size();
+  // Save then restore our private data.
+  CacheFileSaverObserver save_observer(&message_loop_);
+  url_index_->set_save_cache_observer(&save_observer);
+  PostSaveToCacheFileTask();
+  message_loop_.Run();
+  EXPECT_TRUE(save_observer.succeeded_);
 
-  // Prove that there is really something there.
-  ExpectPrivateDataNotEmpty(actual);
+  // Clear and then prove it's clear before restoring.
+  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());
 
-  // Clear and then prove it's clear.
-  actual.Clear();
-  ExpectPrivateDataEmpty(actual);
+  CacheFileReaderObserver read_observer(&message_loop_);
+  url_index_->set_restore_cache_observer(&read_observer);
+  PostRestoreFromCacheFileTask();
+  message_loop_.Run();
+  EXPECT_TRUE(read_observer.succeeded_);
 
-  // Restore the cache.
-  EXPECT_TRUE(actual.RestorePrivateData(index_cache));
-  EXPECT_EQ(kCurrentCacheFileVersion, actual.restored_cache_version_);
+  URLIndexPrivateData& new_data(*GetPrivateData());
 
-  // Compare the restored and expected for equality.
-  ExpectPrivateDataEqual(expected, actual);
+  // 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 = old_data->word_list_.size();
+  for (size_t i = 0; i < count; ++i)
+    EXPECT_EQ(old_data->word_list_[i], new_data.word_list_[i]);
 
-  // Part 2: Save an older version of the cache, restore it, and verify that the
-  // reversioned portions are as expected.
-  URLIndexPrivateData older(expected);
-  in_memory_url_index::InMemoryURLIndexCacheItem older_cache;
-  older.set_saved_cache_version(0);
-  older.SavePrivateData(&older_cache);
+  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_);
 
-  // Version check: Make sure this version does not have the word starts.
-  EXPECT_FALSE(older_cache.has_word_starts_map());
-
-  // Since we shouldn't have saved the word starts information for the version
-  // 0 save immediately above, the cache should be a bit smaller.
-  std::string older_data;
-  EXPECT_TRUE(older_cache.SerializeToString(&older_data));
-  size_t old_version_file_size = older_data.size();
-  EXPECT_LT(old_version_file_size, current_version_cache_size);
-  EXPECT_NE(data, older_data);
-
-  // Clear and then prove it's clear.
-  older.Clear();
-  ExpectPrivateDataEmpty(older);
-
-  // Restore the cache.
-  EXPECT_TRUE(older.RestorePrivateData(older_cache));
-  EXPECT_EQ(0, older.restored_cache_version_);
-
-  // Compare the restored and expected for equality.
-  ExpectPrivateDataEqual(expected, older);
+  for (HistoryInfoMap::const_iterator expected =
+       old_data->history_info_map_.begin();
+       expected != old_data->history_info_map_.end(); ++expected) {
+    HistoryInfoMap::const_iterator 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());
+  }
 }
 
 class InMemoryURLIndexCacheTest : public testing::Test {
  public:
   InMemoryURLIndexCacheTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE;
 
+  // Pass-through functions to simplify our friendship with InMemoryURLIndex.
+  void set_history_dir(const FilePath& dir_path);
+  bool GetCacheFilePath(FilePath* file_path) const;
+
   ScopedTempDir temp_dir_;
   scoped_ptr<InMemoryURLIndex> url_index_;
 };
 
 void InMemoryURLIndexCacheTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   FilePath path(temp_dir_.path());
   url_index_.reset(
       new InMemoryURLIndex(NULL, path, "en,ja,hi,zh"));
 }
 
+void InMemoryURLIndexCacheTest::set_history_dir(const FilePath& dir_path) {
+  return url_index_->set_history_dir(dir_path);
+}
+
+bool InMemoryURLIndexCacheTest::GetCacheFilePath(FilePath* file_path) const {
+  DCHECK(file_path);
+  return url_index_->GetCacheFilePath(file_path);
+}
+
 TEST_F(InMemoryURLIndexCacheTest, CacheFilePath) {
   FilePath expectedPath =
       temp_dir_.path().Append(FILE_PATH_LITERAL("History Provider Cache"));
   std::vector<FilePath::StringType> expected_parts;
   expectedPath.GetComponents(&expected_parts);
   FilePath full_file_path;
-  ASSERT_TRUE(url_index_->GetCacheFilePath(&full_file_path));
+  ASSERT_TRUE(GetCacheFilePath(&full_file_path));
   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();
+  set_history_dir(FilePath());
 }
 
 }  // namespace history