Moves shared history test helpers into util classes.

components/omnibox/browser/history_quick_provider_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 "components/omnibox/browser/history_quick_provider.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
 #include "components/history/core/browser/history_backend.h"
 #include "components/history/core/browser/history_database.h"
-#include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/history/core/browser/url_database.h"
-#include "components/history/core/test/test_history_database.h"
+#include "components/history/core/test/history_service_test_util.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/browser/autocomplete_match.h"
 #include "components/omnibox/browser/autocomplete_result.h"
-#include "components/omnibox/browser/history_index_restore_observer.h"
 #include "components/omnibox/browser/history_url_provider.h"
 #include "components/omnibox/browser/in_memory_url_index.h"
+#include "components/omnibox/browser/in_memory_url_index_test_util.h"
 #include "components/omnibox/browser/mock_autocomplete_provider_client.h"
 #include "components/omnibox/browser/test_scheme_classifier.h"
 #include "components/omnibox/browser/url_index_private_data.h"
 #include "components/search_engines/search_terms_data.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
@@ skipping 122 matching lines @@
 
  private:
   ~GetURLTask() override {}
 
   bool* result_storage_;
   const GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(GetURLTask);
 };
 
-class QuitTask : public history::HistoryDBTask {
- public:
-  QuitTask() {}
-
-  bool RunOnDBThread(history::HistoryBackend* backend,
-                     history::HistoryDatabase* db) override {
-    return true;
-  }
-
-  void DoneRunOnMainThread() override {
-    base::MessageLoop::current()->QuitWhenIdle();
-  }
-
- private:
-  ~QuitTask() override {}
-
-  DISALLOW_COPY_AND_ASSIGN(QuitTask);
-};
-
 class FakeAutocompleteProviderClient : public MockAutocompleteProviderClient {
  public:
-  FakeAutocompleteProviderClient() {
+  FakeAutocompleteProviderClient() : pool_owner_(3, "Background Pool") {
     bookmark_model_ = bookmarks::TestBookmarkClient::CreateModel();
     set_template_url_service(
         make_scoped_ptr(new TemplateURLService(nullptr, 0)));
+    if (history_dir_.CreateUniqueTempDir()) {
+      history_service_ = history::CreateHistoryService(
+          history_dir_.path(), GetAcceptLanguages(), true);
+    }
+
+    in_memory_url_index_.reset(new InMemoryURLIndex(
+        bookmark_model_.get(), history_service_.get(), pool_owner_.pool().get(),
+        history_dir_.path(), GetAcceptLanguages(), SchemeSet()));
+    in_memory_url_index_->Init();
   }
 
   const AutocompleteSchemeClassifier& GetSchemeClassifier() const override {
     return scheme_classifier_;
   }
 
   const SearchTermsData& GetSearchTermsData() const override {
     return search_terms_data_;
   }
 
   history::HistoryService* GetHistoryService() override {
-    return &history_service_;
+    return history_service_.get();
   }
 
   bookmarks::BookmarkModel* GetBookmarkModel() override {
     return bookmark_model_.get();
   }
 
   InMemoryURLIndex* GetInMemoryURLIndex() override {
     return in_memory_url_index_.get();
   }
 
   std::string GetAcceptLanguages() const override { return "en,en-US,ko"; }
 
   void set_in_memory_url_index(scoped_ptr<InMemoryURLIndex> index) {
     in_memory_url_index_ = std::move(index);
   }
 
  private:
+  base::SequencedWorkerPoolOwner pool_owner_;
+  base::ScopedTempDir history_dir_;
   scoped_ptr<bookmarks::BookmarkModel> bookmark_model_;
   TestSchemeClassifier scheme_classifier_;
   SearchTermsData search_terms_data_;
   scoped_ptr<InMemoryURLIndex> in_memory_url_index_;
-  history::HistoryService history_service_;
+  scoped_ptr<history::HistoryService> history_service_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAutocompleteProviderClient);
 };
 
 }  // namespace
 
 class HistoryQuickProviderTest : public testing::Test {
  public:
-  HistoryQuickProviderTest() : pool_owner_(3, "Background Pool") {}
+  HistoryQuickProviderTest() {}
 
  protected:
   class SetShouldContain : public std::unary_function<const std::string&,
                                                       std::set<std::string> > {
    public:
     explicit SetShouldContain(const ACMatches& matched_urls);
 
     void operator()(const std::string& expected);
 
     std::set<std::string> LeftOvers() const { return matches_; }
@@ skipping 35 matching lines @@
   // > message_loop().
   // Direct use of this object in tests is almost certainly not thread-safe.
   history::HistoryBackend* history_backend() {
     return client_->GetHistoryService()->history_backend_.get();
   }
 
   // Call history_backend()->GetURL(url, NULL) on the history thread, returning
   // the result.
   bool GetURLProxy(const GURL& url);
 
-  // Helper functions to initialize the HistoryService.
-  bool InitializeHistoryService();
-  void CreateInMemoryURLIndex();
-  void BlockUntilHistoryProcessesPendingRequests();
-  void BlockUntilHistoryIndexIsRefreshed();
-
   base::MessageLoop message_loop_;
-  base::SequencedWorkerPoolOwner pool_owner_;
-  base::ScopedTempDir history_dir_;
   scoped_ptr<FakeAutocompleteProviderClient> client_;
 
   ACMatches ac_matches_;  // The resulting matches after running RunTest.
 
   scoped_refptr<HistoryQuickProvider> provider_;
 };
 
 void HistoryQuickProviderTest::SetUp() {
   client_.reset(new FakeAutocompleteProviderClient());
-  ASSERT_TRUE(InitializeHistoryService());
+  ASSERT_TRUE(client_->GetHistoryService());
   FillData();
 
-  // |FillData()| must be called before |CreateInMemoryURLIndex()|. This will
+  // |FillData()| must be called before |RebuildFromHistory()|. This will
   // ensure that the index is properly populated with data from the database.
-  CreateInMemoryURLIndex();
-  BlockUntilHistoryIndexIsRefreshed();
+  InMemoryURLIndex* url_index = client_->GetInMemoryURLIndex();
+  url_index->RebuildFromHistory(
+      client_->GetHistoryService()->history_backend_->db());
+  BlockUntilInMemoryURLIndexIsRefreshed(url_index);
+
   // History index refresh creates rebuilt tasks to run on history thread.
   // Block here to make sure that all of them are complete.
-  BlockUntilHistoryProcessesPendingRequests();
+  history::BlockUntilHistoryProcessesPendingRequests(
+      client_->GetHistoryService());
 
   provider_ = new HistoryQuickProvider(client_.get());
 }
 
 void HistoryQuickProviderTest::TearDown() {
   provider_ = NULL;
   // The InMemoryURLIndex must be explicitly shut down or it will DCHECK() in
   // its destructor.
   client_->GetInMemoryURLIndex()->Shutdown();
   client_->set_in_memory_url_index(nullptr);
@@ skipping 146 matching lines @@
   bool result = false;
   client_->GetHistoryService()->ScheduleDBTask(
       scoped_ptr<history::HistoryDBTask>(new GetURLTask(url, &result)),
       &task_tracker);
   // Run the message loop until GetURLTask::DoneRunOnMainThread stops it.  If
   // the test hangs, DoneRunOnMainThread isn't being invoked correctly.
   base::MessageLoop::current()->Run();
   return result;
 }
 
-bool HistoryQuickProviderTest::InitializeHistoryService() {
-  if (!history_dir_.CreateUniqueTempDir() ||
-      !client_->GetHistoryService()->Init(
-          false, client_->GetAcceptLanguages(),
-          history::TestHistoryDatabaseParamsForPath(history_dir_.path())))
-    return false;
-
-  BlockUntilHistoryProcessesPendingRequests();
-  return true;
-}
-
-void HistoryQuickProviderTest::CreateInMemoryURLIndex() {
-  scoped_ptr<InMemoryURLIndex> in_memory_url_index(new InMemoryURLIndex(
-      client_->GetBookmarkModel(), client_->GetHistoryService(),
-      pool_owner_.pool().get(), history_dir_.path(),
-      client_->GetAcceptLanguages(), SchemeSet()));
-  in_memory_url_index->Init();
-  in_memory_url_index->RebuildFromHistory(history_backend()->db());
-  client_->set_in_memory_url_index(std::move(in_memory_url_index));
-}
-
-void HistoryQuickProviderTest::BlockUntilHistoryProcessesPendingRequests() {
-  base::CancelableTaskTracker tracker;
-  client_->GetHistoryService()->ScheduleDBTask(
-      scoped_ptr<history::HistoryDBTask>(new QuitTask()), &tracker);
-  base::MessageLoop::current()->Run();
-}
-
-void HistoryQuickProviderTest::BlockUntilHistoryIndexIsRefreshed() {
-  InMemoryURLIndex* index = client_->GetInMemoryURLIndex();
-  if (!index || index->restored())
-    return;
-  base::RunLoop run_loop;
-  HistoryIndexRestoreObserver observer(run_loop.QuitClosure());
-  index->set_restore_cache_observer(&observer);
-  run_loop.Run();
-  index->set_restore_cache_observer(nullptr);
-  DCHECK(index->restored());
-}
-
 TEST_F(HistoryQuickProviderTest, SimpleSingleMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://slashdot.org/favorite_page.html");
   RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
           ASCIIToUTF16("slashdot.org/favorite_page.html"),
                   ASCIIToUTF16(".org/favorite_page.html"));
 }
 
 TEST_F(HistoryQuickProviderTest, SingleMatchWithCursor) {
   std::vector<std::string> expected_urls;
@@ skipping 422 matching lines @@
 
 TEST_F(HQPOrderingTest, TEAMatch) {
   std::vector<std::string> expected_urls;
   expected_urls.push_back("http://www.teamliquid.net/");
   expected_urls.push_back("http://www.teamliquid.net/tlpd");
   expected_urls.push_back("http://www.teamliquid.net/tlpd/korean/players");
   RunTest(ASCIIToUTF16("tea"), false, expected_urls, true,
           ASCIIToUTF16("www.teamliquid.net"),
                  ASCIIToUTF16("mliquid.net"));
 }