Remove dependencies of InMemoryURLIndex on Profile

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/auto_reset.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 17 matching lines @@
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/in_memory_url_index_types.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
 namespace {
 const size_t kMaxMatches = 3;
+const char kTestLanguages[] = "en,ja,hi,zh";
 }  // namespace
 
 // 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.
@@ skipping 33 matching lines @@
 
 // -----------------------------------------------------------------------------
 
 class InMemoryURLIndexTest : public testing::Test {
  public:
   InMemoryURLIndexTest();
 
  protected:
   // Test setup.
   void SetUp() override;
+  void TearDown() override;
 
   // Allows the database containing the test data to be customized by
   // subclasses.
   virtual base::FilePath::StringType TestDBName() const;
 
+  // Allows the test to control when the InMemoryURLIndex is initialized.
+  virtual bool InitializeInMemoryURLIndexInSetUp() const;
+
+  // Initialize the InMemoryURLIndex for the tests.
+  void InitializeInMemoryURLIndex();
+
   // Validates that the given |term| is contained in |cache| and that it is
   // marked as in-use.
   void CheckTerm(const URLIndexPrivateData::SearchTermCacheMap& cache,
                  base::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;
@@ skipping 10 matching lines @@
   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);
 
   content::TestBrowserThreadBundle thread_bundle_;
+  scoped_ptr<InMemoryURLIndex> url_index_;
   TestingProfile profile_;
   HistoryService* history_service_;
-
-  scoped_ptr<InMemoryURLIndex> url_index_;
   HistoryDatabase* history_database_;
 };
 
 InMemoryURLIndexTest::InMemoryURLIndexTest() {
 }
 
 sql::Connection& InMemoryURLIndexTest::GetDB() {
   return history_database_->GetDB();
 }
 
@@ skipping 126 matching lines @@
       history_database_->FillVisitRow(statement, &row);
       base::Time last_visit = time_right_now;
       for (int64 i = row.visit_time.ToInternalValue(); i > 0; --i)
         last_visit -= day_delta;
       row.visit_time = last_visit;
       history_database_->UpdateVisitRow(row);
     }
     transaction.Commit();
   }
 
-  url_index_.reset(new InMemoryURLIndex(&profile_,
-                                        history_service_,
-                                        base::FilePath(),
-                                        "en,ja,hi,zh",
-                                        history_service_->history_client()));
-  url_index_->Init();
-  url_index_->RebuildFromHistory(history_database_);
+  if (InitializeInMemoryURLIndexInSetUp())
+    InitializeInMemoryURLIndex();
+}
+
+void InMemoryURLIndexTest::TearDown() {
+  // Ensure that the InMemoryURLIndex no longer observer HistoryService before
+  // it is destroyed in order to prevent HistoryService calling dead observer.
+  if (url_index_)
+    url_index_->ShutDown();
 }
 
 base::FilePath::StringType InMemoryURLIndexTest::TestDBName() const {
     return FILE_PATH_LITERAL("url_history_provider_test.db.txt");
 }
 
+bool InMemoryURLIndexTest::InitializeInMemoryURLIndexInSetUp() const {
+  return true;
+}
+
+void InMemoryURLIndexTest::InitializeInMemoryURLIndex() {
+  DCHECK(!url_index_);
+  url_index_.reset(new InMemoryURLIndex(history_service_, base::FilePath(),
+                                        kTestLanguages,
+                                        history_service_->history_client()));
+  url_index_->Init();
+  url_index_->RebuildFromHistory(history_database_);
+}
+
 void InMemoryURLIndexTest::CheckTerm(
     const URLIndexPrivateData::SearchTermCacheMap& cache,
     base::string16 term) const {
   URLIndexPrivateData::SearchTermCacheMap::const_iterator cache_iter(
       cache.find(term));
   ASSERT_TRUE(cache.end() != cache_iter)
       << "Cache does not contain '" << term << "' but should.";
   URLIndexPrivateData::SearchTermCacheItem cache_item = cache_iter->second;
   EXPECT_TRUE(cache_item.used_)
       << "Cache item '" << term << "' should be marked as being in use.";
@@ skipping 114 matching lines @@
                            expected_word_starts.title_word_starts_.end(),
                            actual_word_starts.title_word_starts_.begin()));
   }
 }
 
 //------------------------------------------------------------------------------
 
 class LimitedInMemoryURLIndexTest : public InMemoryURLIndexTest {
  protected:
   base::FilePath::StringType TestDBName() const override;
+  bool InitializeInMemoryURLIndexInSetUp() const override;
 };
 
 base::FilePath::StringType LimitedInMemoryURLIndexTest::TestDBName() const {
   return FILE_PATH_LITERAL("url_history_provider_test_limited.db.txt");
 }
 
+bool LimitedInMemoryURLIndexTest::InitializeInMemoryURLIndexInSetUp() const {
+  return false;
+}
+
 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;"));
   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_,
-                                        history_service_,
-                                        base::FilePath(),
-                                        "en,ja,hi,zh",
-                                        history_service_->history_client()));
-  url_index_->Init();
-  url_index_->RebuildFromHistory(history_database_);
+
+  InitializeInMemoryURLIndex();
   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());
 }
 
 #if defined(OS_WIN)
 // Flaky on windows trybots: http://crbug.com/351500
@@ skipping 712 matching lines @@
   // Compare the captured and restored for equality.
   ExpectPrivateDataEqual(*old_data.get(), new_data);
 }
 
 class InMemoryURLIndexCacheTest : public testing::Test {
  public:
   InMemoryURLIndexCacheTest() {}
 
  protected:
   void SetUp() override;
+  void TearDown() override;
 
   // Pass-through functions to simplify our friendship with InMemoryURLIndex.
   void set_history_dir(const base::FilePath& dir_path);
   bool GetCacheFilePath(base::FilePath* file_path) const;
 
   base::ScopedTempDir temp_dir_;
   scoped_ptr<InMemoryURLIndex> url_index_;
 };
 
 void InMemoryURLIndexCacheTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-  HistoryClient history_client;
   base::FilePath path(temp_dir_.path());
-  url_index_.reset(new InMemoryURLIndex(
-      NULL, nullptr, path, "en,ja,hi,zh", &history_client));
+  url_index_.reset(
+      new InMemoryURLIndex(nullptr, path, kTestLanguages, nullptr));
+}
+
+void InMemoryURLIndexCacheTest::TearDown() {
+  if (url_index_)
+    url_index_->ShutDown();
 }
 
 void InMemoryURLIndexCacheTest::set_history_dir(
     const base::FilePath& dir_path) {
   return url_index_->set_history_dir(dir_path);
 }
 
 bool InMemoryURLIndexCacheTest::GetCacheFilePath(
     base::FilePath* file_path) const {
   DCHECK(file_path);
@@ skipping 11 matching lines @@
   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.
   set_history_dir(base::FilePath());
 }
 
 }  // namespace history