Componentizes shortcuts unittests.

components/omnibox/browser/shortcuts_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/shortcuts_provider.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.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/shortcuts_backend_factory.h"
-#include "chrome/test/base/testing_profile.h"
+#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/thread.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/history/core/browser/url_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_input.h"
 #include "components/omnibox/browser/autocomplete_match.h"
 #include "components/omnibox/browser/autocomplete_provider.h"
 #include "components/omnibox/browser/autocomplete_result.h"
 #include "components/omnibox/browser/in_memory_url_index.h"
+#include "components/omnibox/browser/mock_autocomplete_provider_client.h"
 #include "components/omnibox/browser/shortcuts_backend.h"
-#include "components/prefs/pref_service.h"
-#include "content/public/browser/notification_service.h"
-#include "content/public/test/test_browser_thread.h"
+#include "components/omnibox/browser/test_scheme_classifier.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#if defined(ENABLE_EXTENSIONS)
-#include "extensions/browser/notification_types.h"
-#include "extensions/common/extension.h"
-#include "extensions/common/extension_builder.h"
-#include "extensions/common/value_builder.h"
-#endif
-
 using base::ASCIIToUTF16;
 
 // TestShortcutInfo -----------------------------------------------------------
 
 namespace {
 
 struct TestShortcutInfo {
   std::string guid;
   std::string text;
   std::string fill_into_edit;
@@ skipping 83 matching lines @@
     "0,1,8,3,11,1", "Test - site", "0,0", ui::PAGE_TRANSITION_TYPED,
     AutocompleteMatchType::HISTORY_URL, "", 2, 1 },
   { "BD85DBA2-8C29-49F9-84AE-48E1E90880EF", "ago", "www.daysagotest.com/c.html",
     "http://www.daysagotest.com/c.html", "www.daysagotest.com/c.html",
     "0,1,8,3,11,1", "Test - site", "0,0", ui::PAGE_TRANSITION_TYPED,
     AutocompleteMatchType::HISTORY_URL, "", 3, 1 },
   { "BD85DBA2-8C29-49F9-84AE-48E1E90880F0", "ago", "www.daysagotest.com/d.html",
     "http://www.daysagotest.com/d.html", "www.daysagotest.com/d.html",
     "0,1,8,3,11,1", "Test - site", "0,0", ui::PAGE_TRANSITION_TYPED,
     AutocompleteMatchType::HISTORY_URL, "", 4, 1 },
-  { "BD85DBA2-8C29-49F9-84AE-48E1E90880F1", "echo echo", "echo echo",
-    "chrome-extension://cedabbhfglmiikkmdgcpjdkocfcmbkee/?q=echo",
-    "Run Echo command: echo", "0,0", "Echo", "0,4",
-    ui::PAGE_TRANSITION_TYPED, AutocompleteMatchType::EXTENSION_APP,
-    "echo", 1, 1 },
   { "BD85DBA2-8C29-49F9-84AE-48E1E90880F2", "abcdef.com", "http://abcdef.com",
     "http://abcdef.com/", "Abcdef", "0,1,4,0", "Abcdef", "0,3,4,1",
     ui::PAGE_TRANSITION_TYPED, AutocompleteMatchType::HISTORY_URL, "", 1,
     100 },
   { "BD85DBA2-8C29-49F9-84AE-48E1E90880F3", "query", "query",
     "https://www.google.com/search?q=query", "query", "0,0",
     "Google Search", "0,4", ui::PAGE_TRANSITION_GENERATED,
     AutocompleteMatchType::SEARCH_HISTORY, "", 1, 100 },
   { "BD85DBA2-8C29-49F9-84AE-48E1E90880F4", "word", "www.word",
     "https://www.google.com/search?q=www.word", "www.word", "0,0",
@@ skipping 33 matching lines @@
     "Trailing1 - Space in Shortcut", "0,1",
     "Trailing1 - Space in Shortcut", "0,1", ui::PAGE_TRANSITION_TYPED,
     AutocompleteMatchType::HISTORY_URL, "", 1, 100 },
   { "BD85DBA2-8C29-49F9-84AE-48E1E90880FC", "about:trailing2 ",
     "chrome://trailing2blah", "chrome://trailing2blah/",
     "Trailing2 - Space in Shortcut", "0,1",
     "Trailing2 - Space in Shortcut", "0,1", ui::PAGE_TRANSITION_TYPED,
     AutocompleteMatchType::HISTORY_URL, "", 1, 100 },
 };
 
+class FakeAutocompleteProviderClient
+    : public testing::NiceMock<MockAutocompleteProviderClient> {
+ public:
+  FakeAutocompleteProviderClient()
+      : db_thread_("Test DB thread"),
+        pool_owner_(3, "Background Pool") {
+    set_template_url_service(
+        make_scoped_ptr(new TemplateURLService(nullptr, 0)));
+    if (history_dir_.CreateUniqueTempDir()) {
+      history_service_ = history::CreateHistoryService(
+          history_dir_.path(), std::string(), true);
+    }
+
+    db_thread_.Start();
+    shortcuts_backend_ = new ShortcutsBackend(
+        GetTemplateURLService(), make_scoped_ptr(new SearchTermsData()),
+        history_service_.get(), db_thread_.task_runner(),
+        base::FilePath(), true);
+    shortcuts_backend_->Init();
+  }
+
+  ~FakeAutocompleteProviderClient() override {
+    db_thread_.Stop();
+  }
+
+  history::HistoryService* GetHistoryService() override {
+    return history_service_.get();
+  }
+
+  scoped_refptr<ShortcutsBackend> GetShortcutsBackend() override {
+    return shortcuts_backend_;
+  }
+
+  scoped_refptr<ShortcutsBackend> GetShortcutsBackendIfExists() override {
+    return shortcuts_backend_;
+  }
+
+ private:
+  base::Thread db_thread_;
+  base::SequencedWorkerPoolOwner pool_owner_;
+  base::ScopedTempDir history_dir_;
+  scoped_ptr<history::HistoryService> history_service_;
+  scoped_refptr<ShortcutsBackend> shortcuts_backend_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeAutocompleteProviderClient);
+};
+
 }  // namespace
 
-

[blundell, 2016/02/02 15:37:34]

I believe these blank lines are intended, although clang-format doesn't agree.

[rohitrao (ping after 24h), 2016/02/02 15:42:26]

Yeah, I decided that "---------------------" was a visible enough separator that
I could get rid of the extra blank line.

 // ClassifyTest ---------------------------------------------------------------
 
 // Helper class to make running tests of ClassifyAllMatchesInString() more
 // convenient.
 class ClassifyTest {
  public:
   ClassifyTest(const base::string16& text, ACMatchClassifications matches);
   ~ClassifyTest();
 
   ACMatchClassifications RunTest(const base::string16& find_text);
@@ skipping 10 matching lines @@
 }
 
 ClassifyTest::~ClassifyTest() {
 }
 
 ACMatchClassifications ClassifyTest::RunTest(const base::string16& find_text) {
   return ShortcutsProvider::ClassifyAllMatchesInString(find_text,
       ShortcutsProvider::CreateWordMapForString(find_text), text_, matches_);
 }
 
-
 // ShortcutsProviderTest ------------------------------------------------------
 
 class ShortcutsProviderTest : public testing::Test {
  public:
   ShortcutsProviderTest();
 
  protected:
   typedef std::pair<std::string, bool> ExpectedURLAndAllowedToBeDefault;
   typedef std::vector<ExpectedURLAndAllowedToBeDefault> ExpectedURLs;
 
   class SetShouldContain
       : public std::unary_function<const ExpectedURLAndAllowedToBeDefault&,
                                    std::set<std::string> > {
    public:
     explicit SetShouldContain(const ACMatches& matched_urls);
 
     void operator()(const ExpectedURLAndAllowedToBeDefault& expected);
     std::set<ExpectedURLAndAllowedToBeDefault> Leftovers() const {
-        return matches_;
+      return matches_;
     }
 
    private:
     std::set<ExpectedURLAndAllowedToBeDefault> matches_;
   };
 
   void SetUp() override;
   void TearDown() override;
 
   // Fills test data into the provider.
   void FillData(TestShortcutInfo* db, size_t db_size);
 
   // Runs an autocomplete query on |text| with the provided
   // |prevent_inline_autocomplete| setting and checks to see that the returned
   // results' destination URLs match those provided. |expected_urls| does not
   // need to be in sorted order, but |expected_top_result| should be the top
   // match, and it should have inline autocompletion
   // |top_result_inline_autocompletion|.
   void RunTest(const base::string16 text,
                bool prevent_inline_autocomplete,
                const ExpectedURLs& expected_urls,
                std::string expected_top_result,
                base::string16 top_result_inline_autocompletion);
 
   // Passthrough to the private function in provider_.
   int CalculateScore(const std::string& terms,
                      const ShortcutsDatabase::Shortcut& shortcut,
                      int max_relevance);
 
-  base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread file_thread_;
-
-  TestingProfile profile_;
-  ChromeAutocompleteProviderClient client_;
+  base::MessageLoop message_loop_;
+  scoped_ptr<FakeAutocompleteProviderClient> client_;
+  scoped_refptr<ShortcutsProvider> provider_;
 
   ACMatches ac_matches_;  // The resulting matches after running RunTest.
-
-  scoped_refptr<ShortcutsBackend> backend_;
-  scoped_refptr<ShortcutsProvider> provider_;
 };
 
-ShortcutsProviderTest::ShortcutsProviderTest()
-    : ui_thread_(content::BrowserThread::UI, &message_loop_),
-      file_thread_(content::BrowserThread::FILE, &message_loop_),
-      client_(&profile_) {
+ShortcutsProviderTest::ShortcutsProviderTest() {
 }
 
 void ShortcutsProviderTest::SetUp() {
-  ShortcutsBackendFactory::GetInstance()->SetTestingFactoryAndUse(
-      &profile_, &ShortcutsBackendFactory::BuildProfileNoDatabaseForTesting);
-  backend_ = ShortcutsBackendFactory::GetForProfile(&profile_);
-  ASSERT_TRUE(backend_.get());
-  ASSERT_TRUE(profile_.CreateHistoryService(true, false));
-  provider_ = new ShortcutsProvider(&client_);
+  client_.reset(new FakeAutocompleteProviderClient());
+
+  ASSERT_TRUE(client_->GetShortcutsBackend());
+  provider_ = new ShortcutsProvider(client_.get());
   FillData(shortcut_test_db, arraysize(shortcut_test_db));
 }
 
 void ShortcutsProviderTest::TearDown() {
   // Run all pending tasks or else some threads hold on to the message loop
   // and prevent it from being deleted.
   message_loop_.RunUntilIdle();
-  profile_.DestroyHistoryService();
   provider_ = NULL;
 }
 
 void ShortcutsProviderTest::FillData(TestShortcutInfo* db, size_t db_size) {
   DCHECK(provider_.get());
-  size_t expected_size = backend_->shortcuts_map().size() + db_size;
+  scoped_refptr<ShortcutsBackend> backend = client_->GetShortcutsBackend();
+  size_t expected_size = backend->shortcuts_map().size() + db_size;
   for (size_t i = 0; i < db_size; ++i) {
     const TestShortcutInfo& cur = db[i];
     ShortcutsDatabase::Shortcut shortcut(
         cur.guid, ASCIIToUTF16(cur.text),
         ShortcutsDatabase::Shortcut::MatchCore(
             ASCIIToUTF16(cur.fill_into_edit), GURL(cur.destination_url),
             ASCIIToUTF16(cur.contents), cur.contents_class,
             ASCIIToUTF16(cur.description), cur.description_class,
             cur.transition, cur.type, ASCIIToUTF16(cur.keyword)),
         base::Time::Now() - base::TimeDelta::FromDays(cur.days_from_now),
         cur.number_of_hits);
-    backend_->AddShortcut(shortcut);
+    backend->AddShortcut(shortcut);
   }
-  EXPECT_EQ(expected_size, backend_->shortcuts_map().size());
+  EXPECT_EQ(expected_size, backend->shortcuts_map().size());
 }
 
 ShortcutsProviderTest::SetShouldContain::SetShouldContain(
     const ACMatches& matched_urls) {
   for (ACMatches::const_iterator iter = matched_urls.begin();
        iter != matched_urls.end(); ++iter)
     matches_.insert(ExpectedURLAndAllowedToBeDefault(
         iter->destination_url.spec(), iter->allowed_to_be_default_match));
 }
 
 void ShortcutsProviderTest::SetShouldContain::operator()(
     const ExpectedURLAndAllowedToBeDefault& expected) {
   EXPECT_EQ(1U, matches_.erase(expected));
 }
 
 void ShortcutsProviderTest::RunTest(
     const base::string16 text,
     bool prevent_inline_autocomplete,
     const ExpectedURLs& expected_urls,
     std::string expected_top_result,
     base::string16 top_result_inline_autocompletion) {
   base::MessageLoop::current()->RunUntilIdle();
   AutocompleteInput input(text, base::string16::npos, std::string(), GURL(),
                           metrics::OmniboxEventProto::INVALID_SPEC,
                           prevent_inline_autocomplete, false, true, true, false,
-                          ChromeAutocompleteSchemeClassifier(&profile_));
+                          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.
@@ skipping 17 matching lines @@
 }
 
 int ShortcutsProviderTest::CalculateScore(
     const std::string& terms,
     const ShortcutsDatabase::Shortcut& shortcut,
     int max_relevance) {
   return provider_->CalculateScore(ASCIIToUTF16(terms), shortcut,
                                    max_relevance);
 }
 
-
 // Actual tests ---------------------------------------------------------------
 
 TEST_F(ShortcutsProviderTest, SimpleSingleMatch) {
   base::string16 text(ASCIIToUTF16("go"));
   std::string expected_url("http://www.google.com/");
   ExpectedURLs expected_urls;
   expected_urls.push_back(ExpectedURLAndAllowedToBeDefault(expected_url, true));
   RunTest(text, false, expected_urls, expected_url, ASCIIToUTF16("ogle.com"));
 
   // Same test with prevent inline autocomplete.
@@ skipping 365 matching lines @@
     { "BD85DBA2-8C29-49F9-84AE-48E1E90881F3", "keep", "www.deletetest.com/1/2",
       "http://www.deletetest.com/1/2", "http://www.deletetest.com/1/2", "0,2",
       "Keep this shortcut!", "0,0", ui::PAGE_TRANSITION_TYPED,
       AutocompleteMatchType::HISTORY_TITLE, "", 1, 1},
     { "BD85DBA2-8C29-49F9-84AE-48E1E90881F4", "delete", "www.deletetest.com/2",
       "http://www.deletetest.com/2", "http://www.deletetest.com/2", "0,2",
       "Erase this shortcut!", "0,0", ui::PAGE_TRANSITION_TYPED,
       AutocompleteMatchType::HISTORY_URL, "", 1, 1},
   };
 
-  size_t original_shortcuts_count = backend_->shortcuts_map().size();
+  scoped_refptr<ShortcutsBackend> backend = client_->GetShortcutsBackend();
+  size_t original_shortcuts_count = backend->shortcuts_map().size();
 
   FillData(shortcuts_to_test_delete, arraysize(shortcuts_to_test_delete));
 
-  EXPECT_EQ(original_shortcuts_count + 4, backend_->shortcuts_map().size());
-  EXPECT_FALSE(backend_->shortcuts_map().end() ==
-               backend_->shortcuts_map().find(ASCIIToUTF16("delete")));
-  EXPECT_FALSE(backend_->shortcuts_map().end() ==
-               backend_->shortcuts_map().find(ASCIIToUTF16("erase")));
+  EXPECT_EQ(original_shortcuts_count + 4, backend->shortcuts_map().size());
+  EXPECT_FALSE(backend->shortcuts_map().end() ==
+               backend->shortcuts_map().find(ASCIIToUTF16("delete")));
+  EXPECT_FALSE(backend->shortcuts_map().end() ==
+               backend->shortcuts_map().find(ASCIIToUTF16("erase")));
 
   AutocompleteMatch match(
       provider_.get(), 1200, true, AutocompleteMatchType::HISTORY_TITLE);
 
   match.destination_url = GURL(shortcuts_to_test_delete[0].destination_url);
   match.contents = ASCIIToUTF16(shortcuts_to_test_delete[0].contents);
   match.description = ASCIIToUTF16(shortcuts_to_test_delete[0].description);
 
   provider_->DeleteMatch(match);
 
   // shortcuts_to_test_delete[0] and shortcuts_to_test_delete[1] should be
   // deleted, but not shortcuts_to_test_delete[2] or
   // shortcuts_to_test_delete[3], which have different URLs.
-  EXPECT_EQ(original_shortcuts_count + 2, backend_->shortcuts_map().size());
-  EXPECT_FALSE(backend_->shortcuts_map().end() ==
-               backend_->shortcuts_map().find(ASCIIToUTF16("delete")));
-  EXPECT_TRUE(backend_->shortcuts_map().end() ==
-              backend_->shortcuts_map().find(ASCIIToUTF16("erase")));
+  EXPECT_EQ(original_shortcuts_count + 2, backend->shortcuts_map().size());
+  EXPECT_FALSE(backend->shortcuts_map().end() ==
+               backend->shortcuts_map().find(ASCIIToUTF16("delete")));
+  EXPECT_TRUE(backend->shortcuts_map().end() ==
+              backend->shortcuts_map().find(ASCIIToUTF16("erase")));
 
   match.destination_url = GURL(shortcuts_to_test_delete[3].destination_url);
   match.contents = ASCIIToUTF16(shortcuts_to_test_delete[3].contents);
   match.description = ASCIIToUTF16(shortcuts_to_test_delete[3].description);
 
   provider_->DeleteMatch(match);
-  EXPECT_EQ(original_shortcuts_count + 1, backend_->shortcuts_map().size());
-  EXPECT_TRUE(backend_->shortcuts_map().end() ==
-              backend_->shortcuts_map().find(ASCIIToUTF16("delete")));
+  EXPECT_EQ(original_shortcuts_count + 1, backend->shortcuts_map().size());
+  EXPECT_TRUE(backend->shortcuts_map().end() ==
+              backend->shortcuts_map().find(ASCIIToUTF16("delete")));
 }
 
 TEST_F(ShortcutsProviderTest, DoesNotProvideOnFocus) {
   AutocompleteInput input(
       ASCIIToUTF16("about:o"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, false, false, true, true, true,
-      ChromeAutocompleteSchemeClassifier(&profile_));
+      TestSchemeClassifier());
   provider_->Start(input, false);
   EXPECT_TRUE(provider_->matches().empty());
 }
-
-#if defined(ENABLE_EXTENSIONS)
-TEST_F(ShortcutsProviderTest, Extension) {
-  // Try an input string that matches an extension URL.
-  base::string16 text(ASCIIToUTF16("echo"));
-  std::string expected_url(
-      "chrome-extension://cedabbhfglmiikkmdgcpjdkocfcmbkee/?q=echo");
-  ExpectedURLs expected_urls;
-  expected_urls.push_back(ExpectedURLAndAllowedToBeDefault(
-      expected_url, true));
-  RunTest(text, false, expected_urls, expected_url, ASCIIToUTF16(" echo"));
-
-  // Claim the extension has been unloaded.
-  scoped_refptr<const extensions::Extension> extension =
-      extensions::ExtensionBuilder()
-          .SetManifest(std::move(extensions::DictionaryBuilder()
-                                     .Set("name", "Echo")
-                                     .Set("version", "1.0")))
-          .SetID("cedabbhfglmiikkmdgcpjdkocfcmbkee")
-          .Build();
-  extensions::UnloadedExtensionInfo details(
-      extension.get(), extensions::UnloadedExtensionInfo::REASON_UNINSTALL);
-  content::NotificationService::current()->Notify(
-      extensions::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
-      content::Source<Profile>(&profile_),
-      content::Details<extensions::UnloadedExtensionInfo>(&details));
-
-  // Now the URL should have disappeared.
-  RunTest(text, false, ExpectedURLs(), std::string(), base::string16());
-}
-#endif