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/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 "components/search_engines/template_url_service_client.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 "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)
       : AutocompleteProvider(AutocompleteProvider::TYPE_SEARCH),
         listener_(NULL),
@@ skipping 111 matching lines @@
     const base::string16 keyword;
     const base::string16 expected_associated_keyword;
   };
 
   struct AssistedQueryStatsTestData {
     const AutocompleteMatch::Type match_type;
     const std::string expected_aqs;
   };
 
  protected:
+  ~AutocompleteProviderTest() override {}
+
    // Registers a test TemplateURL under the given keyword.
   void RegisterTemplateURL(const base::string16 keyword,
                            const std::string& template_url);
 
   // Resets |controller_| with two TestProviders.  |provider1_ptr| and
   // |provider2_ptr| are updated to point to the new providers if non-NULL.
   void ResetControllerWithTestProviders(bool same_destinations,
                                         TestProvider** provider1_ptr,
                                         TestProvider** provider2_ptr);
 
+  void SetUp() override;
+
   // Runs a query on the input "a", and makes sure both providers' input is
   // properly collected.
   void RunTest();
 
   // Constructs an AutocompleteResult from |match_data|, sets the |controller_|
   // to pretend it was running against input |input|, calls the |controller_|'s
   // UpdateAssociatedKeywords, and checks that the matches have associated
   // keywords as expected.
   void RunKeywordTest(const base::string16& input,
                       const KeywordTestData* match_data,
@@ skipping 32 matching lines @@
  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_;
   scoped_ptr<AutocompleteController> controller_;
+  scoped_ptr<MockAutocompleteProviderClient> client_;
 };
 
+void AutocompleteProviderTest::SetUp() {
+  scoped_ptr<TemplateURLService> template_url_service(
+      new TemplateURLService(
+          nullptr, scoped_ptr<SearchTermsData>(new SearchTermsData),
+          nullptr, scoped_ptr<TemplateURLServiceClient>(), nullptr,
+          nullptr, base::Closure()));
+  client_.reset(new NiceMock<MockAutocompleteProviderClient>());
+  client_->set_template_url_service(template_url_service.Pass());
+}
+
 void AutocompleteProviderTest::RegisterTemplateURL(
     const base::string16 keyword,
     const std::string& template_url) {
   if (TemplateURLServiceFactory::GetForProfile(&profile_) == NULL) {

[droger, 2015/10/28 16:56:47]

You have to remove this call to TemplateURLServiceFactory.

[Abhishek, 2015/10/30 14:15:55]

Done.

     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_);

[droger, 2015/10/28 16:56:47]

Here you need to use the TemplateURLService you created.
I am not sure if you can get it from client_, because it is a mock.
Maybe you need to have the TemplateURLService as a member of
AutocompleteProviderTest.

[Abhishek, 2015/10/30 14:15:55]

Actually I'm able to get the TemplateURLService from client_ if I'm making in
NiceMock.


I'm not sure, but I think its require here for one more reason, as it's required
to replace ChromeAutocompleteProviderClient uses.

WDYT?

[droger, 2015/11/02 10:21:46]

I don't understand what you are asking here. If you can get the client from the
mock, then it should be fine, no?

   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 139 matching lines @@
     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());
   }
@@ skipping 25 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() {
@@ skipping 254 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());
 }