Componentizes history_quick_provider_unittest.cc.

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 "chrome/browser/autocomplete/chrome_autocomplete_provider_client.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
-#include "chrome/browser/autocomplete/in_memory_url_index_factory.h"
-#include "chrome/browser/bookmarks/bookmark_model_factory.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/test/base/testing_browser_process.h"
-#include "chrome/test/base/testing_profile.h"
+#include "base/test/sequenced_worker_pool_owner.h"
+#include "components/bookmarks/browser/bookmark_model.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"

[blundell, 2016/01/26 08:40:25]

Did you double-check that all of the dependencies in this file are already in
the relevant test targets?

[rohitrao (ping after 24h), 2016/01/26 14:15:47]

Added "//base/test:test_support".  Everything else looked like it was already
there.

+#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/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/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 "content/public/test/test_browser_thread.h"
-#include "content/public/test/test_utils.h"
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::Time;
 using base::TimeDelta;
 
-using content::BrowserThread;
-
 namespace {
 
 struct TestURLInfo {
   std::string url;
   std::string title;
   int visit_count;
   int typed_count;
   int days_from_now;
 } quick_test_db[] = {
   {"http://www.google.com/", "Google", 3, 3, 0},
@@ skipping 109 matching lines @@
 
  private:
   ~GetURLTask() override {}
 
   bool* result_storage_;
   const GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(GetURLTask);
 };
 
+class QuitTask : public history::HistoryDBTask {

[blundell, 2016/01/26 08:40:25]

How much duplication is there between this stuff and what you added in the
HistoryURLProvider unittest? Is now the right time to split this stuff out?

[rohitrao (ping after 24h), 2016/01/26 14:15:47]

QuitTask is identical, FakeAutocompleteProviderClient looks very similar.  I was
going to componentize one more test (InMemoryURLProviderTest) and then pull out
the common test support code.  I'm not yet sure if CreateInMemoryURLIndex() will
be shared amongst tests or not.

+ 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() {
+    bookmark_model_ = bookmark_client_.CreateModel();
+    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_;
+  }
+
+  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:
+  bookmarks::TestBookmarkClient bookmark_client_;
+  scoped_ptr<bookmarks::BookmarkModel> bookmark_model_;
+
+  TestSchemeClassifier scheme_classifier_;
+  SearchTermsData search_terms_data_;
+  scoped_ptr<InMemoryURLIndex> in_memory_url_index_;
+  history::HistoryService history_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeAutocompleteProviderClient);
+};
+
 }  // namespace
 
 class HistoryQuickProviderTest : public testing::Test {
  public:
-  HistoryQuickProviderTest()
-      : ui_thread_(BrowserThread::UI, &message_loop_),
-        file_thread_(BrowserThread::FILE, &message_loop_) {}
+  HistoryQuickProviderTest() : pool_owner_(3, "Background Pool") {}
 
  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_; }
 
    private:
     std::set<std::string> matches_;
   };
 
-  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()));
-  }
-
   void SetUp() override;
   void TearDown() override;
 
   virtual void GetTestData(size_t* data_count, TestURLInfo** test_data);
 
   // 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. |expected_urls| does not
@@ skipping 13 matching lines @@
                          bool can_inline_top_result,
                          base::string16 expected_fill_into_edit,
                          base::string16 autocompletion);
 
   // TODO(shess): From history_service.h in reference to history_backend:
   // > This class has most of the implementation and runs on the 'thread_'.
   // > You MUST communicate with this class ONLY through the thread_'s
   // > message_loop().
   // Direct use of this object in tests is almost certainly not thread-safe.
   history::HistoryBackend* history_backend() {
-    return history_service_->history_backend_.get();
+    return client_->GetHistoryService()->history_backend_.get();
   }
 
   // Call history_backend()->GetURL(url, NULL) on the history thread, returning
   // the result.
   bool GetURLProxy(const GURL& url);
 
-  base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
+  // Helper functions to initialize the HistoryService.
+  bool InitializeHistoryService(bool delete_file, bool no_db);
+  void CreateInMemoryURLIndex();
+  void BlockUntilHistoryProcessesPendingRequests();
+  void BlockUntilHistoryIndexIsRefreshed();
 
-  scoped_ptr<TestingProfile> profile_;
-  scoped_ptr<ChromeAutocompleteProviderClient> client_;
-  history::HistoryService* history_service_;
+  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() {
-  profile_.reset(new TestingProfile());
-  client_.reset(new ChromeAutocompleteProviderClient(profile_.get()));
-  ASSERT_TRUE(profile_->CreateHistoryService(true, false));
-  profile_->CreateBookmarkModel(true);
-  bookmarks::test::WaitForBookmarkModelToLoad(
-      BookmarkModelFactory::GetForProfile(profile_.get()));
-  profile_->BlockUntilHistoryIndexIsRefreshed();
+  client_.reset(new FakeAutocompleteProviderClient());
+  ASSERT_TRUE(InitializeHistoryService(true, false));
+  FillData();
+
+  CreateInMemoryURLIndex();
+  BlockUntilHistoryIndexIsRefreshed();
   // History index refresh creates rebuilt tasks to run on history thread.
   // Block here to make sure that all of them are complete.
-  profile_->BlockUntilHistoryProcessesPendingRequests();
-  history_service_ = HistoryServiceFactory::GetForProfile(
-      profile_.get(), ServiceAccessType::EXPLICIT_ACCESS);
-  EXPECT_TRUE(history_service_);
+  BlockUntilHistoryProcessesPendingRequests();
+
   provider_ = new HistoryQuickProvider(client_.get());
-  TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-      profile_.get(), &HistoryQuickProviderTest::CreateTemplateURLService);
-  FillData();
-  InMemoryURLIndex* index =
-      InMemoryURLIndexFactory::GetForProfile(profile_.get());
-  EXPECT_TRUE(index);
-  index->RebuildFromHistory(history_backend()->db());
 }
 
 void HistoryQuickProviderTest::TearDown() {
   provider_ = NULL;
+  client_->GetInMemoryURLIndex()->Shutdown();

[blundell, 2016/01/26 08:40:25]

Comment on why these two lines are necessary?

[rohitrao (ping after 24h), 2016/01/26 14:15:48]

Done.

+  client_->set_in_memory_url_index(nullptr);
   // History index rebuild task is created from main thread during SetUp,
   // performed on DB thread and must be deleted on main thread.
   // Run main loop to process delete task, to prevent leaks.
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 void HistoryQuickProviderTest::GetTestData(size_t* data_count,
                                            TestURLInfo** test_data) {
   DCHECK(data_count);
   DCHECK(test_data);
@@ skipping 76 matching lines @@
     bool prevent_inline_autocomplete,
     std::vector<std::string> expected_urls,
     bool can_inline_top_result,
     base::string16 expected_fill_into_edit,
     base::string16 expected_autocompletion) {
   SCOPED_TRACE(text);  // Minimal hint to query being run.
   base::MessageLoop::current()->RunUntilIdle();
   AutocompleteInput input(text, cursor_position, std::string(), GURL(),
                           metrics::OmniboxEventProto::INVALID_SPEC,
                           prevent_inline_autocomplete, false, true, true, false,
-                          ChromeAutocompleteSchemeClassifier(profile_.get()));
+                          TestSchemeClassifier());
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->done());
 
   ac_matches_ = provider_->matches();
 
   // We should have gotten back at most AutocompleteProvider::kMaxMatches.
   EXPECT_LE(ac_matches_.size(), AutocompleteProvider::kMaxMatches);
 
   // If the number of expected and actual matches aren't equal then we need
   // test no further, but let's do anyway so that we know which URLs failed.
   EXPECT_EQ(expected_urls.size(), ac_matches_.size());
 
   // Verify that all expected URLs were found and that all found URLs
   // were expected.
   std::set<std::string> leftovers =
       for_each(expected_urls.begin(), expected_urls.end(),
                SetShouldContain(ac_matches_)).LeftOvers();
   EXPECT_EQ(0U, leftovers.size()) << "There were " << leftovers.size()
       << " unexpected results, one of which was: '"
       << *(leftovers.begin()) << "'.";
 
   if (expected_urls.empty())
     return;
 
+  ASSERT_GT(ac_matches_.size(), 0U);
   // Verify that we got the results in the order expected.
   int best_score = ac_matches_.begin()->relevance + 1;
   int i = 0;
   std::vector<std::string>::const_iterator expected = expected_urls.begin();
   for (ACMatches::const_iterator actual = ac_matches_.begin();
        actual != ac_matches_.end() && expected != expected_urls.end();
        ++actual, ++expected, ++i) {
     EXPECT_EQ(*expected, actual->destination_url.spec())
         << "For result #" << i << " we got '" << actual->destination_url.spec()
         << "' but expected '" << *expected << "'.";
     EXPECT_LT(actual->relevance, best_score)
       << "At result #" << i << " (url=" << actual->destination_url.spec()
       << "), we noticed scores are not monotonically decreasing.";
     best_score = actual->relevance;
   }
 
   EXPECT_EQ(can_inline_top_result, ac_matches_[0].allowed_to_be_default_match);
   if (can_inline_top_result)
     EXPECT_EQ(expected_autocompletion, ac_matches_[0].inline_autocompletion);
   EXPECT_EQ(expected_fill_into_edit, ac_matches_[0].fill_into_edit);
 }
 
 bool HistoryQuickProviderTest::GetURLProxy(const GURL& url) {
   base::CancelableTaskTracker task_tracker;
   bool result = false;
-  history_service_->ScheduleDBTask(
+  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(bool delete_file,
+                                                        bool no_db) {
+  if (!history_dir_.CreateUniqueTempDir())
+    return false;
+
+  if (!client_->GetHistoryService()->Init(
+          no_db, client_->GetAcceptLanguages(),
+          history::TestHistoryDatabaseParamsForPath(history_dir_.path())))
+    return false;
+
+  if (!no_db)
+    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() {

[blundell, 2016/01/26 08:40:25]

Same question as above.

[rohitrao (ping after 24h), 2016/01/26 14:15:47]

This will go into the shared test code, but I haven't yet decided if it should
go into a HistoryTestUtil file or just directly into
FakeAutocompleteProviderClient.

+  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(NULL);
+  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 211 matching lines @@
   EXPECT_EQ(1U, ac_matches_.size());
   EXPECT_TRUE(GetURLProxy(test_url));
   provider_->DeleteMatch(ac_matches_[0]);
 
   // Check that the underlying URL is deleted from the history DB (this implies
   // that all visits are gone as well). Also verify that a deletion notification
   // is sent, in response to which the secondary data stores (InMemoryDatabase,
   // InMemoryURLIndex) will drop any data they might have pertaining to the URL.
   // To ensure that the deletion has been propagated everywhere before we start
   // verifying post-deletion states, first wait until we see the notification.
-  WaitForURLsDeletedNotification(history_service_);
+  WaitForURLsDeletedNotification(client_->GetHistoryService());
   EXPECT_FALSE(GetURLProxy(test_url));
 
   // Just to be on the safe side, explicitly verify that we have deleted enough
   // data so that we will not be serving the same result again.
   expected_urls.clear();
   RunTest(ASCIIToUTF16("slashdot"), false, expected_urls, true,
           ASCIIToUTF16("NONE EXPECTED"), base::string16());
 }
 
 TEST_F(HistoryQuickProviderTest, PreventBeatingURLWhatYouTypedMatch) {
@@ skipping 94 matching lines @@
   RunTest(ASCIIToUTF16("popularsitewithroot.com/"), true, expected_urls, true,
           ASCIIToUTF16("popularsitewithroot.com"), base::string16());
 }
 
 TEST_F(HistoryQuickProviderTest, 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();
 
   // A search results page should not be returned when typing a query.
   std::vector<std::string> expected_urls;
   RunTest(ASCIIToUTF16("thequery"), false, expected_urls, false,
           ASCIIToUTF16("anotherengine.com/?q=thequery"), base::string16());
 
   // A search results page should not be returned when typing the engine URL.
   expected_urls.clear();
   expected_urls.push_back("http://testsearch.com/");
   RunTest(ASCIIToUTF16("testsearch"), false, expected_urls, true,
           ASCIIToUTF16("testsearch.com"),
                     ASCIIToUTF16(".com"));
 }
 
 TEST_F(HistoryQuickProviderTest, DoesNotProvideMatchesOnFocus) {
-  AutocompleteInput input(
-      ASCIIToUTF16("popularsite"), base::string16::npos, std::string(), GURL(),
-      metrics::OmniboxEventProto::INVALID_SPEC, false, false, true, true, true,
-      ChromeAutocompleteSchemeClassifier(profile_.get()));
+  AutocompleteInput input(ASCIIToUTF16("popularsite"), base::string16::npos,
+                          std::string(), GURL(),
+                          metrics::OmniboxEventProto::INVALID_SPEC, false,
+                          false, true, true, true, TestSchemeClassifier());
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->matches().empty());
 }
 
 // HQPOrderingTest -------------------------------------------------------------
 
 TestURLInfo ordering_test_db[] = {
   {"http://www.teamliquid.net/tlpd/korean/games/21648_bisu_vs_iris", "", 6, 3,
       256},
   {"http://www.amazon.com/", "amazon.com: online shopping for electronics, "
@@ skipping 52 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"));
 }