Removing bad dependencies from autocomplete_provider_unittest

chrome/browser/autocomplete/autocomplete_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/autocomplete_provider.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
+#include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_provider_client.h"
-#include "chrome/browser/autocomplete/chrome_autocomplete_scheme_classifier.h"
-#include "chrome/browser/chrome_notification_types.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 "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/browser/autocomplete_controller.h"
 #include "components/omnibox/browser/autocomplete_input.h"
 #include "components/omnibox/browser/autocomplete_match.h"
 #include "components/omnibox/browser/autocomplete_provider_listener.h"
 #include "components/omnibox/browser/keyword_provider.h"
+#include "components/omnibox/browser/mock_autocomplete_provider_client.h"
 #include "components/omnibox/browser/search_provider.h"
 #include "components/search_engines/search_engines_switches.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
-#include "content/public/browser/notification_source.h"
-#include "content/public/test/test_browser_thread_bundle.h"
+#include "components/search_engines/template_url_service_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using testing::NiceMock;
+
 static std::ostream& operator<<(std::ostream& os,
                                 const AutocompleteResult::const_iterator& it) {
   return os << static_cast<const AutocompleteMatch*>(&(*it));
 }
 
 namespace {
 const size_t kResultsPerProvider = 3;
 const char kTestTemplateURLKeyword[] = "t";
-}
+
+class TestingSchemeClassifier : public AutocompleteSchemeClassifier {
+ public:
+  metrics::OmniboxInputType::Type GetInputTypeForScheme(
+      const std::string& scheme) const override {
+    if (net::URLRequest::IsHandledProtocol(scheme))
+      return metrics::OmniboxInputType::URL;
+    return metrics::OmniboxInputType::INVALID;
+  }
+};
+
+} // namespace
 
 // Autocomplete provider that provides known results. Note that this is
 // refcounted so that it can also be a task on the message loop.
 class TestProvider : public AutocompleteProvider {
  public:
-  TestProvider(int relevance, const base::string16& prefix,
-               Profile* profile,
-               const base::string16 match_keyword)
+  TestProvider(int relevance,
+               const base::string16& prefix,
+               const base::string16 match_keyword,
+               AutocompleteProviderClient* client)
       : AutocompleteProvider(AutocompleteProvider::TYPE_SEARCH),
         listener_(NULL),
-        profile_(profile),
         relevance_(relevance),
         prefix_(prefix),
-        match_keyword_(match_keyword) {
+        match_keyword_(match_keyword),
+        client_(client) {
   }
 
   void Start(const AutocompleteInput& input, bool minimal_changes) override;
 
   void set_listener(AutocompleteProviderListener* listener) {
     listener_ = listener;
   }
 
  private:
   ~TestProvider() override {}
 
   void Run();
 
   void AddResults(int start_at, int num);
   void AddResultsWithSearchTermsArgs(
       int start_at,
       int num,
       AutocompleteMatch::Type type,
       const TemplateURLRef::SearchTermsArgs& search_terms_args);
 
   AutocompleteProviderListener* listener_;
-  Profile* profile_;
   int relevance_;
   const base::string16 prefix_;
   const base::string16 match_keyword_;
+  AutocompleteProviderClient* client_;
 };
 
 void TestProvider::Start(const AutocompleteInput& input, bool minimal_changes) {
   if (minimal_changes)
     return;
 
   matches_.clear();
 
   if (input.from_omnibox_focus())
     return;
@@ skipping 48 matching lines @@
     match.contents = match.fill_into_edit;
     match.contents_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     match.description = match.fill_into_edit;
     match.description_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
     match.search_terms_args.reset(
         new TemplateURLRef::SearchTermsArgs(search_terms_args));
     if (!match_keyword_.empty()) {
       match.keyword = match_keyword_;
-      TemplateURLService* service =
-          TemplateURLServiceFactory::GetForProfile(profile_);
+      TemplateURLService* service = client_->GetTemplateURLService();
       ASSERT_TRUE(match.GetTemplateURL(service, false) != NULL);
     }
 
     matches_.push_back(match);
   }
 }
 
 class AutocompleteProviderTest : public testing::Test,
-                                 public content::NotificationObserver {
+                                 public MockAutocompleteProviderClient {
+ public:
+  ~AutocompleteProviderTest() override {}
+  AutocompleteProviderTest();
+
+  void OnAutocompleteControllerResultReady(
+      AutocompleteController* controller) override;
+
  protected:
   struct KeywordTestData {
     const base::string16 fill_into_edit;
     const base::string16 keyword;
     const base::string16 expected_associated_keyword;
   };
 
   struct AssistedQueryStatsTestData {
     const AutocompleteMatch::Type match_type;
     const std::string expected_aqs;
@@ skipping 46 matching lines @@
     return controller_->search_provider_->field_trial_triggered_in_session();
   }
   void set_current_page_classification(
       metrics::OmniboxEventProto::PageClassification classification) {
     controller_->input_.current_page_classification_ = classification;
   }
 
   AutocompleteResult result_;
 
  private:
-  // content::NotificationObserver:
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
 
-  content::TestBrowserThreadBundle thread_bundle_;
-  content::NotificationRegistrar registrar_;
-  TestingProfile profile_;
+  base::MessageLoop message_loop_;
   scoped_ptr<AutocompleteController> controller_;

[droger, 2015/11/04 14:29:59]

Add a comment here:
  MockAutocompleteProviderClient* client_;  // Owned by |controller_|.

[Abhishek, 2015/11/09 14:28:27]

Done.

+  MockAutocompleteProviderClient* client_;
 };
 
+AutocompleteProviderTest::AutocompleteProviderTest()
+    : client_(new MockAutocompleteProviderClient()) {
+  scoped_ptr<TemplateURLService> template_url_service(
+      new TemplateURLService(nullptr, 0));
+  client_->set_template_url_service(template_url_service.Pass());
+}
+
+void AutocompleteProviderTest::OnAutocompleteControllerResultReady(
+    AutocompleteController* controller) {
+  if (controller->done()) {
+    CopyResults();
+    base::MessageLoop::current()->QuitWhenIdle();
+  }
+}
+
 void AutocompleteProviderTest::RegisterTemplateURL(
     const base::string16 keyword,
     const std::string& template_url) {
-  if (TemplateURLServiceFactory::GetForProfile(&profile_) == NULL) {
-    TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-        &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
-  }
   TemplateURLData data;
   data.SetURL(template_url);
   data.SetShortName(keyword);
   data.SetKeyword(keyword);
   TemplateURL* default_t_url = new TemplateURL(data);
-  TemplateURLService* turl_model =
-      TemplateURLServiceFactory::GetForProfile(&profile_);
+  TemplateURLService* turl_model = client_->GetTemplateURLService();
   turl_model->Add(default_t_url);
   turl_model->SetUserSelectedDefaultSearchProvider(default_t_url);
   turl_model->Load();
   TemplateURLID default_provider_id = default_t_url->id();
   ASSERT_NE(0, default_provider_id);
 }
 
 void AutocompleteProviderTest::ResetControllerWithTestProviders(
     bool same_destinations,
     TestProvider** provider1_ptr,
@@ skipping 10 matching lines @@
   //       (B > A).
   RegisterTemplateURL(base::ASCIIToUTF16(kTestTemplateURLKeyword),
                       "http://aqs/{searchTerms}/{google:assistedQueryStats}");
 
   AutocompleteController::Providers providers;
 
   // Construct two new providers, with either the same or different prefixes.
   TestProvider* provider1 = new TestProvider(
       kResultsPerProvider,
       base::ASCIIToUTF16("http://a"),
-      &profile_,
-      base::ASCIIToUTF16(kTestTemplateURLKeyword));
+      base::ASCIIToUTF16(kTestTemplateURLKeyword), client_);
   providers.push_back(provider1);
 
   TestProvider* provider2 = new TestProvider(
       kResultsPerProvider * 2,
       same_destinations ? base::ASCIIToUTF16("http://a")
                         : base::ASCIIToUTF16("http://b"),
-      &profile_,
-      base::string16());
+      base::string16(), client_);
   providers.push_back(provider2);
 
   // Reset the controller to contain our new providers.
-  controller_.reset(new AutocompleteController(
+  controller_.reset(
+      new AutocompleteController(make_scoped_ptr(client_), NULL, 0));
 
-      make_scoped_ptr(new ChromeAutocompleteProviderClient(&profile_)), NULL,
-      0));
   // We're going to swap the providers vector, but the old vector should be
   // empty so no elements need to be freed at this point.
   EXPECT_TRUE(controller_->providers_.empty());
   controller_->providers_.swap(providers);
   provider1->set_listener(controller_.get());
   provider2->set_listener(controller_.get());
 
   // The providers don't complete synchronously, so listen for "result updated"
   // notifications.

[droger, 2015/11/04 14:29:59]

Remove this comment, it's no longer accurate.

[Abhishek, 2015/11/09 14:28:27]

Done.

-  registrar_.Add(this,
-                 chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
-                 content::Source<AutocompleteController>(controller_.get()));
+  client_->OnAutocompleteControllerResultReady(controller_.get());
 
   if (provider1_ptr)
     *provider1_ptr = provider1;
   if (provider2_ptr)
     *provider2_ptr = provider2;
 }
 
 void AutocompleteProviderTest::
     ResetControllerWithKeywordAndSearchProviders() {
-  TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-      &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
-
   // Reset the default TemplateURL.
   TemplateURLData data;
   data.SetShortName(base::ASCIIToUTF16("default"));
   data.SetKeyword(base::ASCIIToUTF16("default"));
   data.SetURL("http://defaultturl/{searchTerms}");
   TemplateURL* default_t_url = new TemplateURL(data);
-  TemplateURLService* turl_model =
-      TemplateURLServiceFactory::GetForProfile(&profile_);
+  TemplateURLService* turl_model = client_->GetTemplateURLService();
   turl_model->Add(default_t_url);
   turl_model->SetUserSelectedDefaultSearchProvider(default_t_url);
   TemplateURLID default_provider_id = default_t_url->id();
   ASSERT_NE(0, default_provider_id);
 
   // Create another TemplateURL for KeywordProvider.
   TemplateURLData data2;
   data2.SetShortName(base::ASCIIToUTF16("k"));
   data2.SetKeyword(base::ASCIIToUTF16("k"));
   data2.SetURL("http://keyword/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(data2);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   controller_.reset(new AutocompleteController(
-
-      make_scoped_ptr(new ChromeAutocompleteProviderClient(&profile_)), NULL,
+      make_scoped_ptr(client_), NULL,
       AutocompleteProvider::TYPE_KEYWORD | AutocompleteProvider::TYPE_SEARCH));
 }
 
 void AutocompleteProviderTest::ResetControllerWithKeywordProvider() {
-  TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-      &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
-
-  TemplateURLService* turl_model =
-      TemplateURLServiceFactory::GetForProfile(&profile_);
+  TemplateURLService* turl_model = client_->GetTemplateURLService();
 
   // Create a TemplateURL for KeywordProvider.
   TemplateURLData data;
   data.SetShortName(base::ASCIIToUTF16("foo.com"));
   data.SetKeyword(base::ASCIIToUTF16("foo.com"));
   data.SetURL("http://foo.com/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   // Make a TemplateURL for KeywordProvider that a shorter version of the
   // first.
   data.SetShortName(base::ASCIIToUTF16("f"));
   data.SetKeyword(base::ASCIIToUTF16("f"));
   data.SetURL("http://f.com/{searchTerms}");
   keyword_t_url = new TemplateURL(data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   // Create another TemplateURL for KeywordProvider.
   data.SetShortName(base::ASCIIToUTF16("bar.com"));
   data.SetKeyword(base::ASCIIToUTF16("bar.com"));
   data.SetURL("http://bar.com/{searchTerms}");
   keyword_t_url = new TemplateURL(data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   controller_.reset(new AutocompleteController(
-      make_scoped_ptr(new ChromeAutocompleteProviderClient(&profile_)), NULL,
+      make_scoped_ptr(client_), NULL,
       AutocompleteProvider::TYPE_KEYWORD));
 }
 
 void AutocompleteProviderTest::RunTest() {
   RunQuery(base::ASCIIToUTF16("a"));
 }
 
 void AutocompleteProviderTest::RunKeywordTest(const base::string16& input,
                                               const KeywordTestData* match_data,
                                               size_t size) {
   ACMatches matches;
   for (size_t i = 0; i < size; ++i) {
     AutocompleteMatch match;
     match.relevance = 1000;  // Arbitrary non-zero value.
     match.allowed_to_be_default_match = true;
     match.fill_into_edit = match_data[i].fill_into_edit;
     match.transition = ui::PAGE_TRANSITION_KEYWORD;
     match.keyword = match_data[i].keyword;
     matches.push_back(match);
   }
 
   controller_->input_ = AutocompleteInput(
       input, base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS,
       false, true, true, true, false,
-      ChromeAutocompleteSchemeClassifier(&profile_));
+      TestingSchemeClassifier());
   AutocompleteResult result;
   result.AppendMatches(controller_->input_, matches);
   controller_->UpdateAssociatedKeywords(&result);
-
   for (size_t j = 0; j < result.size(); ++j) {
     EXPECT_EQ(match_data[j].expected_associated_keyword,
               result.match_at(j)->associated_keyword.get() ?
                   result.match_at(j)->associated_keyword->keyword :
                   base::string16());
   }
 }
 
 void AutocompleteProviderTest::RunAssistedQueryStatsTest(
     const AssistedQueryStatsTestData* aqs_test_data,
@@ skipping 21 matching lines @@
     EXPECT_EQ(aqs_test_data[i].expected_aqs,
               result_.match_at(i)->search_terms_args->assisted_query_stats);
   }
 }
 
 void AutocompleteProviderTest::RunQuery(const base::string16 query) {
   result_.Reset();
   controller_->Start(AutocompleteInput(
       query, base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, true, false, true, true, false,
-      ChromeAutocompleteSchemeClassifier(&profile_)));
+      TestingSchemeClassifier()));
 
   if (!controller_->done())
     // The message loop will terminate when all autocomplete input has been
     // collected.
     base::MessageLoop::current()->Run();
 }
 
 void AutocompleteProviderTest::RunExactKeymatchTest(
     bool allow_exact_keyword_match) {
   // Send the controller input which exactly matches the keyword provider we
   // created in ResetControllerWithKeywordAndSearchProviders().  The default
   // match should thus be a search-other-engine match iff
   // |allow_exact_keyword_match| is true.  Regardless, the match should
   // be from SearchProvider.  (It provides all verbatim search matches,
   // keyword or not.)
   controller_->Start(AutocompleteInput(
       base::ASCIIToUTF16("k test"), base::string16::npos, std::string(), GURL(),
       metrics::OmniboxEventProto::INVALID_SPEC, true, false,
       allow_exact_keyword_match, false, false,
-      ChromeAutocompleteSchemeClassifier(&profile_)));
+      TestingSchemeClassifier()));
   EXPECT_TRUE(controller_->done());
   EXPECT_EQ(AutocompleteProvider::TYPE_SEARCH,
       controller_->result().default_match()->provider->type());
   EXPECT_EQ(allow_exact_keyword_match ?
       AutocompleteMatchType::SEARCH_OTHER_ENGINE :
       AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
       controller_->result().default_match()->type);
 }
 
 void AutocompleteProviderTest::CopyResults() {
   result_.CopyFrom(controller_->result());
 }
 
 GURL AutocompleteProviderTest::GetDestinationURL(
     AutocompleteMatch match,
     base::TimeDelta query_formulation_time) const {
   controller_->UpdateMatchDestinationURLWithQueryFormulationTime(
       query_formulation_time, &match);
   return match.destination_url;
 }
 
-void AutocompleteProviderTest::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  if (controller_->done()) {
-    CopyResults();
-    base::MessageLoop::current()->QuitWhenIdle();
-  }
-}
-
 // Tests that the default selection is set properly when updating results.
 TEST_F(AutocompleteProviderTest, Query) {
   TestProvider* provider1 = NULL;
   TestProvider* provider2 = NULL;
   ResetControllerWithTestProviders(false, &provider1, &provider2);
   RunTest();
 
   // Make sure the default match gets set to the highest relevance match.  The
   // highest relevance matches should come from the second provider.
   EXPECT_EQ(kResultsPerProvider * 2, result_.size());
@@ skipping 104 matching lines @@
 // Test that exact match keywords trump keywords associated with
 // the match.
 TEST_F(AutocompleteProviderTest, ExactMatchKeywords) {
   ResetControllerWithKeywordProvider();
 
   {
     KeywordTestData keyword_match[] = {
       { base::ASCIIToUTF16("foo.com"), base::string16(),
         base::ASCIIToUTF16("foo.com") }
     };
-
     SCOPED_TRACE("keyword match as usual");
     RunKeywordTest(base::ASCIIToUTF16("fo"), keyword_match,
                    arraysize(keyword_match));
   }
 
   // The same result set with an input of "f" (versus "fo") should get
   // a different associated keyword because "f" is an exact match for
   // a keyword and that should trump the keyword normally associated with
   // this match.
   {
@@ skipping 98 matching lines @@
   EXPECT_FALSE(search_provider_field_trial_triggered_in_session());
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j0j4&", url.path());
 
   // Test page classification and field trial triggered set.
   set_search_provider_field_trial_triggered_in_session(true);
   EXPECT_TRUE(search_provider_field_trial_triggered_in_session());
   url = GetDestinationURL(match, base::TimeDelta::FromMilliseconds(2456));
   EXPECT_EQ("//aqs=chrome.0.69i57j69i58j5l2j0l3j69i59.2456j1j4&", url.path());
 }