Componentizes history_url_provider_unittest.cc.

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 "chrome/browser/autocomplete/chrome_autocomplete_provider_client.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
-#include "chrome/browser/history/history_service_factory.h"
-#include "chrome/browser/search_engines/chrome_template_url_service_client.h"
-#include "chrome/browser/search_engines/template_url_service_factory.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/test/base/testing_browser_process.h"
-#include "chrome/test/base/testing_profile.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/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 "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
-using content::TestBrowserThreadBundle;
+namespace {
 
 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},
 
@@ skipping 92 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() {
+    set_template_url_service(
+        make_scoped_ptr(new TemplateURLService(nullptr, 0)));
+  }
+
+  const AutocompleteSchemeClassifier& GetSchemeClassifier() const override {
+    return scheme_classifier_;
+  }
+
+  const SearchTermsData& GetSearchTermsData() const override {
+    return search_terms_data_;
+  }
+
+  history::HistoryService* GetHistoryService() override {
+    return &history_service_;
+  }
+
+ private:
+  TestSchemeClassifier scheme_classifier_;
+  SearchTermsData search_terms_data_;
+  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:
-  static scoped_ptr<KeyedService> CreateTemplateURLService(
-      content::BrowserContext* context) {
-    Profile* profile = static_cast<Profile*>(context);
-    return make_scoped_ptr(new TemplateURLService(
-        profile->GetPrefs(), make_scoped_ptr(new SearchTermsData), NULL,
-        scoped_ptr<TemplateURLServiceClient>(new ChromeTemplateURLServiceClient(
-            HistoryServiceFactory::GetForProfile(
-                profile, ServiceAccessType::EXPLICIT_ACCESS))),
-        NULL, NULL, base::Closure()));
-  }
-
   // testing::Test
   void SetUp() override {
     ASSERT_TRUE(SetUpImpl(false));
   }
   void TearDown() override;
 
   // Does the real setup.
   bool SetUpImpl(bool no_db) WARN_UNUSED_RESULT;
 
   // Fills test data into the history system.
@@ skipping 13 matching lines @@
   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);
   }
 
-  content::TestBrowserThreadBundle thread_bundle_;
+  // 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<TestingProfile> profile_;
-  scoped_ptr<ChromeAutocompleteProviderClient> client_;
+  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));
   }
 };
 
 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) {
-  profile_.reset(new TestingProfile());
-  client_.reset(new ChromeAutocompleteProviderClient(profile_.get()));
-  if (!(profile_->CreateHistoryService(true, no_db)))
+  client_.reset(new FakeAutocompleteProviderClient());
+
+  if (!InitializeHistoryService(true, no_db))
     return false;
-  if (!no_db) {
-    profile_->BlockUntilHistoryProcessesPendingRequests();
-    profile_->BlockUntilHistoryIndexIsRefreshed();
-  }
-  profile_->GetPrefs()->SetString(prefs::kAcceptLanguages, "en-US,en,ko");
-  history_service_ = HistoryServiceFactory::GetForProfile(
-      profile_.get(), ServiceAccessType::EXPLICIT_ACCESS);
+  EXPECT_CALL(*client_, GetAcceptLanguages())
+      .WillRepeatedly(testing::Return("en-US,en,ko"));
 
   autocomplete_ = new HistoryURLProvider(client_.get(), this);
-  TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-      profile_.get(), &HistoryURLProviderTest::CreateTemplateURLService);
   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
@@ skipping 24 matching lines @@
 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) {
   AutocompleteInput input(text, base::string16::npos, desired_tld, GURL(),
                           metrics::OmniboxEventProto::INVALID_SPEC,
                           prevent_inline_autocomplete, false, true, true, false,
-                          ChromeAutocompleteSchemeClassifier(profile_.get()));
+                          TestSchemeClassifier());
   *identified_input_type = input.type();
   autocomplete_->Start(input, false);
   if (!autocomplete_->done())
     base::MessageLoop::current()->Run();
 
   matches_ = autocomplete_->matches();
   if (sort_matches_) {
-    TemplateURLService* service =
-        TemplateURLServiceFactory::GetForProfile(profile_.get());
+    TemplateURLService* service = client_->GetTemplateURLService();
     for (ACMatches::iterator i = matches_.begin(); i != matches_.end(); ++i) {
       i->ComputeStrippedDestinationURL(
           input, client_->GetAcceptLanguages(), service);
     }
     AutocompleteResult::DedupMatchesByDestination(
         input.current_page_classification(), false, &matches_);
     std::sort(matches_.begin(), matches_.end(),
               &AutocompleteMatch::MoreRelevant);
   }
   ASSERT_EQ(num_results, matches_.size()) << "Input text: " << text
@@ skipping 294 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.
-  profile_->BlockUntilHistoryProcessesPendingRequests();
+  BlockUntilHistoryProcessesPendingRequests();
 
   AutocompleteInput input(
       ASCIIToUTF16("pa"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, false, false, true, true, false,
-      ChromeAutocompleteSchemeClassifier(profile_.get()));
+      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.
   matches_ = autocomplete_->matches();
   ASSERT_GT(matches_.size(), 0u);
   EXPECT_EQ(GURL("http://pandora.com/"), matches_[0].destination_url);
   int pandora_relevance = matches_[0].relevance;
 
@@ skipping 21 matching lines @@
   RunTest(ASCIIToUTF16("slash"), std::string(), false, navigation_2,
           arraysize(navigation_2));
 
   RunTest(ASCIIToUTF16("this is a query"), std::string(), false, NULL, 0);
 }
 
 TEST_F(HistoryURLProviderTest, DontAutocompleteOnTrailingWhitespace) {
   AutocompleteInput input(
       ASCIIToUTF16("slash "), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, false, false, true, true, false,
-      ChromeAutocompleteSchemeClassifier(profile_.get()));
+      TestSchemeClassifier());
   autocomplete_->Start(input, false);
   if (!autocomplete_->done())
     base::MessageLoop::current()->Run();
 
   // None of the matches should attempt to autocomplete.
   matches_ = autocomplete_->matches();
   for (size_t i = 0; i < matches_.size(); ++i) {
     EXPECT_TRUE(matches_[i].inline_autocompletion.empty());
     EXPECT_FALSE(matches_[i].allowed_to_be_default_match);
   }
@@ skipping 117 matching lines @@
   // This test passes if we don't crash.  The results don't matter.
   const char* const test_cases[] = {
     "//c",
     "\\@st",
     "view-source:x",
   };
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     AutocompleteInput input(
         ASCIIToUTF16(test_cases[i]), base::string16::npos, std::string(),
         GURL(), metrics::OmniboxEventProto::INVALID_SPEC, false, false, true,
-        true, false, ChromeAutocompleteSchemeClassifier(profile_.get()));
+        true, false, TestSchemeClassifier());
     autocomplete_->Start(input, false);
     if (!autocomplete_->done())
       base::MessageLoop::current()->Run();
   }
 }
 
 TEST_F(HistoryURLProviderTest, DoesNotProvideMatchesOnFocus) {
   AutocompleteInput input(
       ASCIIToUTF16("foo"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, false, false, true, true, true,
-      ChromeAutocompleteSchemeClassifier(profile_.get()));
+      TestSchemeClassifier());
   autocomplete_->Start(input, false);
   EXPECT_TRUE(autocomplete_->matches().empty());
 }
 
 TEST_F(HistoryURLProviderTest, DoesNotInlinePunycodeMatches) {
   // A URL that matches due to a match in the punycode URL are allowed to be the
   // default match if the URL doesn't get rendered as international characters
   // in the given locale.
   const UrlAndLegalDefault expected_true[] = {
     { "http://puny.xn--1lq90ic7f1rc.cn/", true },
@@ skipping 14 matching lines @@
   RunTest(ASCIIToUTF16("puny.xn--1l"), std::string(), false, expected_true,
           arraysize(expected_true));
   RunTest(ASCIIToUTF16("puny.xn--1lq90ic7f1rc"), std::string(), false,
           expected_true, arraysize(expected_true));
   RunTest(ASCIIToUTF16("puny.xn--1lq90ic7f1rc."), std::string(), false,
           expected_true, arraysize(expected_true));
   // Set the language so the punycode part of the URL is rendered as
   // international characters.  Then this match should not be allowed to be
   // the default match if the inline autocomplete text starts in the middle
   // of the international characters.
-  profile_->GetPrefs()->SetString(prefs::kAcceptLanguages, "zh-CN");
+  EXPECT_CALL(*client_, GetAcceptLanguages())
+      .WillRepeatedly(testing::Return("zh-CN"));
   RunTest(ASCIIToUTF16("pun"), std::string(), false, expected_true,
           arraysize(expected_true));
   RunTest(ASCIIToUTF16("puny."), std::string(), false, expected_true,
           arraysize(expected_true));
   RunTest(ASCIIToUTF16("puny.x"), std::string(), false, expected_false,
           arraysize(expected_false));
   RunTest(ASCIIToUTF16("puny.xn"), std::string(), false, expected_false,
           arraysize(expected_false));
   RunTest(ASCIIToUTF16("puny.xn--"), std::string(), false, expected_false,
           arraysize(expected_false));
   RunTest(ASCIIToUTF16("puny.xn--1l"), std::string(), false, expected_false,
           arraysize(expected_false));
   RunTest(ASCIIToUTF16("puny.xn--1lq90ic7f1rc"), std::string(), false,
           expected_true, arraysize(expected_true));
   RunTest(ASCIIToUTF16("puny.xn--1lq90ic7f1rc."), std::string(), false,
           expected_true, arraysize(expected_true));
 }
 
 TEST_F(HistoryURLProviderTest, CullSearchResults) {
   // Set up a default search engine.
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("TestEngine"));
   data.SetKeyword(ASCIIToUTF16("TestEngine"));
   data.SetURL("http://testsearch.com/?q={searchTerms}");
-  TemplateURLService* template_url_service =
-      TemplateURLServiceFactory::GetForProfile(profile_.get());
+  TemplateURLService* template_url_service = client_->GetTemplateURLService();
   TemplateURL* template_url = new TemplateURL(data);
   template_url_service->Add(template_url);
   template_url_service->SetUserSelectedDefaultSearchProvider(template_url);
   template_url_service->Load();
 
   // URLs we will be using, plus the visit counts they will initially get
   // (the redirect set below will also increment the visit counts). We want
   // the results to be in A,B,C order. Note also that our visit counts are
   // all high enough so that domain synthesizing won't get triggered.
   struct TestCase {
@@ skipping 84 matching lines @@
   };
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     SCOPED_TRACE(testing::Message() << "Index " << i << " input: "
                                     << test_cases[i].input << ", trim_http: "
                                     << test_cases[i].trim_http);
 
     AutocompleteInput input(
         ASCIIToUTF16(test_cases[i].input), base::string16::npos, std::string(),
         GURL("about:blank"), metrics::OmniboxEventProto::INVALID_SPEC, false,
         false, true, true, false,
-        ChromeAutocompleteSchemeClassifier(profile_.get()));
+        TestSchemeClassifier());
     AutocompleteMatch match(autocomplete_->SuggestExactInput(
         input, input.canonicalized_url(), test_cases[i].trim_http));
     EXPECT_EQ(ASCIIToUTF16(test_cases[i].contents), match.contents);
     for (size_t match_index = 0; match_index < match.contents_class.size();
          ++match_index) {
       EXPECT_EQ(test_cases[i].offsets[match_index],
                 match.contents_class[match_index].offset);
       EXPECT_EQ(ACMatchClassification::URL |
                 (match_index == test_cases[i].match_classification_index ?
                  ACMatchClassification::MATCH : 0),
@@ skipping 92 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);
     }
   }
 }