Moves shared history test helpers into util classes.

components/omnibox/browser/history_url_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_url_provider.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/files/scoped_temp_dir.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/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
-#include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_service.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/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/browser/autocomplete_match.h"
 #include "components/omnibox/browser/autocomplete_provider.h"
 #include "components/omnibox/browser/autocomplete_provider_listener.h"
 #include "components/omnibox/browser/autocomplete_result.h"
 #include "components/omnibox/browser/history_quick_provider.h"
 #include "components/omnibox/browser/mock_autocomplete_provider_client.h"
 #include "components/omnibox/browser/test_scheme_classifier.h"
 #include "components/search_engines/default_search_manager.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 "components/url_formatter/url_fixer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
+const char kDefaultAcceptLanguages[] = "en-US,en,ko";
+
 struct TestURLInfo {
   const char* url;
   const char* title;
   int visit_count;
   int typed_count;
   int age_in_days;
 } test_db[] = {
   {"http://www.google.com/", "Google", 3, 3, 80},
 
   // High-quality pages should get a host synthesized as a lower-quality match.
@@ skipping 91 matching lines @@
   // For experimental HUP scoring test.
   {"http://7.com/1a", "One", 8, 4, 4},
   {"http://7.com/2a", "Two A", 4, 2, 8},
   {"http://7.com/2b", "Two B", 4, 1, 8},
   {"http://7.com/3a", "Three", 2, 1, 16},
   {"http://7.com/4a", "Four A", 1, 1, 32},
   {"http://7.com/4b", "Four B", 1, 1, 64},
   {"http://7.com/5a", "Five A", 8, 0, 64},  // never typed.
 };
 
-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(bool create_history_db) {
     set_template_url_service(
         make_scoped_ptr(new TemplateURLService(nullptr, 0)));
+    if (history_dir_.CreateUniqueTempDir()) {
+      history_service_ = history::CreateHistoryService(
+          history_dir_.path(), kDefaultAcceptLanguages, create_history_db);
+    }
   }
 
   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();
   }
 
  private:
   TestSchemeClassifier scheme_classifier_;
   SearchTermsData search_terms_data_;
-  history::HistoryService history_service_;
+  base::ScopedTempDir history_dir_;
+  scoped_ptr<history::HistoryService> history_service_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeAutocompleteProviderClient);
 };
 
 }  // namespace
 
 class HistoryURLProviderTest : public testing::Test,
                                public AutocompleteProviderListener {
  public:
   struct UrlAndLegalDefault {
     std::string url;
     bool allowed_to_be_default_match;
   };
 
   HistoryURLProviderTest()
       : sort_matches_(false) {
     HistoryQuickProvider::set_disabled(true);
   }
 
   ~HistoryURLProviderTest() override {
     HistoryQuickProvider::set_disabled(false);
   }
 
   // AutocompleteProviderListener:
   void OnProviderUpdate(bool updated_matches) override;
 
  protected:
   // testing::Test
-  void SetUp() override {
-    ASSERT_TRUE(SetUpImpl(false));
-  }
+  void SetUp() override { ASSERT_TRUE(SetUpImpl(true)); }
   void TearDown() override;
 
   // Does the real setup.
-  bool SetUpImpl(bool no_db) WARN_UNUSED_RESULT;
+  bool SetUpImpl(bool create_history_db) WARN_UNUSED_RESULT;
 
   // Fills test data into the history system.
   void FillData();
 
   // Runs an autocomplete query on |text| and checks to see that the returned
   // results' destination URLs match those provided.  Also allows checking
   // that the input type was identified correctly.
   void RunTest(const base::string16& text,
                const std::string& desired_tld,
                bool prevent_inline_autocomplete,
                const UrlAndLegalDefault* expected_urls,
                size_t num_results,
                metrics::OmniboxInputType::Type* identified_input_type);
 
   // A version of the above without the final |type| output parameter.
   void RunTest(const base::string16& text,
                const std::string& desired_tld,
                bool prevent_inline_autocomplete,
                const UrlAndLegalDefault* expected_urls,
                size_t num_results) {
     metrics::OmniboxInputType::Type type;
     return RunTest(text, desired_tld, prevent_inline_autocomplete,
                    expected_urls, num_results, &type);
   }
 
-  // Helper functions to initialize the HistoryService.
-  bool InitializeHistoryService(bool delete_file, bool no_db);
-  void BlockUntilHistoryProcessesPendingRequests();
-
   base::MessageLoop message_loop_;
-  base::ScopedTempDir history_dir_;
   ACMatches matches_;
   scoped_ptr<FakeAutocompleteProviderClient> client_;
-  history::HistoryService* history_service_;
   scoped_refptr<HistoryURLProvider> autocomplete_;
   // Should the matches be sorted and duplicates removed?
   bool sort_matches_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryURLProviderTest);
 };
 
 class HistoryURLProviderTestNoDB : public HistoryURLProviderTest {
  protected:
-  void SetUp() override {
-    ASSERT_TRUE(SetUpImpl(true));
-  }
+  void SetUp() override { ASSERT_TRUE(SetUpImpl(false)); }
 };
 
 class HistoryURLProviderTestNoSearchProvider : public HistoryURLProviderTest {
  protected:
   void SetUp() override {
     DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(true);
     HistoryURLProviderTest::SetUp();
   }
 
   void TearDown() override {
     HistoryURLProviderTest::TearDown();
     DefaultSearchManager::SetFallbackSearchEnginesDisabledForTesting(false);
   }
 };
 
 void HistoryURLProviderTest::OnProviderUpdate(bool updated_matches) {
   if (autocomplete_->done())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
-bool HistoryURLProviderTest::InitializeHistoryService(
-    bool delete_file, bool no_db) {
-  if (!history_dir_.CreateUniqueTempDir())
-    return false;
-
-  history_service_ = client_->GetHistoryService();
-  if (!history_service_->Init(
-          no_db, std::string(),
-          history::TestHistoryDatabaseParamsForPath(history_dir_.path())))
-    return false;
-
-  if (!no_db)
-    BlockUntilHistoryProcessesPendingRequests();
-
-  return true;
-}
-
-void HistoryURLProviderTest::BlockUntilHistoryProcessesPendingRequests() {
-  base::CancelableTaskTracker tracker;
-  client_->GetHistoryService()->ScheduleDBTask(
-      scoped_ptr<history::HistoryDBTask>(new QuitTask()), &tracker);
-  base::MessageLoop::current()->Run();
-}
-
-bool HistoryURLProviderTest::SetUpImpl(bool no_db) {
-  client_.reset(new FakeAutocompleteProviderClient());
-
-  if (!InitializeHistoryService(true, no_db))
+bool HistoryURLProviderTest::SetUpImpl(bool create_history_db) {
+  client_.reset(new FakeAutocompleteProviderClient(create_history_db));
+  if (!client_->GetHistoryService())
     return false;
   EXPECT_CALL(*client_, GetAcceptLanguages())
-      .WillRepeatedly(testing::Return("en-US,en,ko"));
-
+      .WillRepeatedly(testing::Return(kDefaultAcceptLanguages));
   autocomplete_ = new HistoryURLProvider(client_.get(), this);
   FillData();
   return true;
 }
 
 void HistoryURLProviderTest::TearDown() {
   autocomplete_ = NULL;
 }
 
 void HistoryURLProviderTest::FillData() {
   // Most visits are a long time ago (some tests require this since we do some
   // special logic for things visited very recently). Note that this time must
   // be more recent than the "expire history" threshold for the data to be kept
   // in the main database.
   //
   // TODO(brettw) It would be nice if we could test this behavior, in which
   // case the time would be specifed in the test_db structure.
   const Time now = Time::Now();
 
   for (size_t i = 0; i < arraysize(test_db); ++i) {
     const TestURLInfo& cur = test_db[i];
     const GURL current_url(cur.url);
-    history_service_->AddPageWithDetails(
+    client_->GetHistoryService()->AddPageWithDetails(
         current_url, base::UTF8ToUTF16(cur.title), cur.visit_count,
         cur.typed_count, now - TimeDelta::FromDays(cur.age_in_days), false,
         history::SOURCE_BROWSED);
   }
 
-  history_service_->AddPageWithDetails(
+  client_->GetHistoryService()->AddPageWithDetails(
       GURL("http://pa/"), base::UTF8ToUTF16("pa"), 0, 0,
       Time::Now() -
-      TimeDelta::FromDays(history::kLowQualityMatchAgeLimitInDays - 1),
+          TimeDelta::FromDays(history::kLowQualityMatchAgeLimitInDays - 1),
       false, history::SOURCE_BROWSED);
 }
 
 void HistoryURLProviderTest::RunTest(
     const base::string16& text,
     const std::string& desired_tld,
     bool prevent_inline_autocomplete,
     const UrlAndLegalDefault* expected_urls,
     size_t num_results,
     metrics::OmniboxInputType::Type* identified_input_type) {
@@ skipping 167 matching lines @@
   // all high enough so that domain synthesizing won't get triggered.
   struct TestCase {
     const char* url;
     int count;
   } test_cases[] = {
     {"http://redirects/A", 30},
     {"http://redirects/B", 20},
     {"http://redirects/C", 10}
   };
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    history_service_->AddPageWithDetails(GURL(test_cases[i].url),
-        ASCIIToUTF16("Title"), test_cases[i].count, test_cases[i].count,
-        Time::Now(), false, history::SOURCE_BROWSED);
+    client_->GetHistoryService()->AddPageWithDetails(
+        GURL(test_cases[i].url), ASCIIToUTF16("Title"), test_cases[i].count,
+        test_cases[i].count, Time::Now(), false, history::SOURCE_BROWSED);
   }
 
   // Create a B->C->A redirect chain, but set the visit counts such that they
   // will appear in A,B,C order in the results. The autocomplete query will
   // search for the most recent visit when looking for redirects, so this will
   // be found even though the previous visits had no redirects.
   history::RedirectList redirects_to_a;
   redirects_to_a.push_back(GURL(test_cases[1].url));
   redirects_to_a.push_back(GURL(test_cases[2].url));
   redirects_to_a.push_back(GURL(test_cases[0].url));
-  history_service_->AddPage(GURL(test_cases[0].url), base::Time::Now(),
-      NULL, 0, GURL(), redirects_to_a, ui::PAGE_TRANSITION_TYPED,
-      history::SOURCE_BROWSED, true);
+  client_->GetHistoryService()->AddPage(
+      GURL(test_cases[0].url), base::Time::Now(), NULL, 0, GURL(),
+      redirects_to_a, ui::PAGE_TRANSITION_TYPED, history::SOURCE_BROWSED, true);
 
   // Because all the results are part of a redirect chain with other results,
   // all but the first one (A) should be culled. We should get the default
   // "what you typed" result, plus this one.
   const base::string16 typing(ASCIIToUTF16("http://redirects/"));
   const UrlAndLegalDefault expected_results[] = {
     { test_cases[0].url, false },
     { base::UTF16ToUTF8(typing), true }
   };
   RunTest(typing, std::string(), true, expected_results,
@@ skipping 113 matching lines @@
     { "http://www.17173.com/", true }
   };
   RunTest(ASCIIToUTF16("17173"), std::string(), false, fixup_5,
           arraysize(fixup_5));
 }
 
 // Make sure the results for the input 'p' don't change between the first and
 // second passes.
 TEST_F(HistoryURLProviderTest, EmptyVisits) {
   // Wait for history to create the in memory DB.
-  BlockUntilHistoryProcessesPendingRequests();
+  history::BlockUntilHistoryProcessesPendingRequests(
+      client_->GetHistoryService());
 
   AutocompleteInput input(
       ASCIIToUTF16("pa"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, false, false, true, true, false,
       TestSchemeClassifier());
   autocomplete_->Start(input, false);
   // HistoryURLProvider shouldn't be done (waiting on async results).
   EXPECT_FALSE(autocomplete_->done());
 
   // We should get back an entry for pandora.
@@ skipping 255 matching lines @@
   // all high enough so that domain synthesizing won't get triggered.
   struct TestCase {
     const char* url;
     int count;
   } test_cases[] = {
     {"https://testsearch.com/", 30},
     {"https://testsearch.com/?q=foobar", 20},
     {"http://foobar.com/", 10}
   };
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
-    history_service_->AddPageWithDetails(GURL(test_cases[i].url),
-        base::UTF8ToUTF16("Title"), test_cases[i].count, test_cases[i].count,
-        Time::Now(), false, history::SOURCE_BROWSED);
+    client_->GetHistoryService()->AddPageWithDetails(
+        GURL(test_cases[i].url), base::UTF8ToUTF16("Title"),
+        test_cases[i].count, test_cases[i].count, Time::Now(), false,
+        history::SOURCE_BROWSED);
   }
 
   // We should not see search URLs when typing a previously used query.
   const UrlAndLegalDefault expected_when_searching_query[] = {
     { test_cases[2].url, false }
   };
   RunTest(ASCIIToUTF16("foobar"), std::string(), true,
       expected_when_searching_query, arraysize(expected_when_searching_query));
 
   // We should not see search URLs when typing the search engine name.
@@ skipping 176 matching lines @@
     // the default experimental scoring.
     autocomplete_->scoring_params_.experimental_scoring_enabled = true;
     ASSERT_NO_FATAL_FAILURE(RunTest(ASCIIToUTF16(test_cases[i].input),
                                     std::string(), false, output, max_matches));
     for (int j = 0; j < max_matches; ++j) {
       EXPECT_EQ(test_cases[i].matches[j].experiment_relevance,
                 matches_[j].relevance);
     }
   }
 }