Prepare AutocompleteController for componentization

components/omnibox/keyword_provider_unittest.cc

 // Copyright 2014 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 "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/autocomplete_match.h"
 #include "components/omnibox/autocomplete_scheme_classifier.h"
 #include "components/omnibox/keyword_provider.h"
+#include "components/omnibox/mock_autocomplete_provider_client.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 "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 using base::ASCIIToUTF16;
 
 namespace {
 
 class TestingSchemeClassifier : public AutocompleteSchemeClassifier {
  public:
   metrics::OmniboxInputType::Type GetInputTypeForScheme(
@@ skipping 29 matching lines @@
 
   template<class ResultType>
   void RunTest(TestData<ResultType>* keyword_cases,
                int num_cases,
                ResultType AutocompleteMatch::* member);
 
  protected:
   static const TemplateURLService::Initializer kTestData[];
 
   scoped_refptr<KeywordProvider> kw_provider_;
-  scoped_ptr<TemplateURLService> model_;
+  scoped_ptr<MockAutocompleteProviderClient> client_;
 };
 
 // static
 const TemplateURLService::Initializer KeywordProviderTest::kTestData[] = {
   { "aa", "aa.com?foo={searchTerms}", "aa" },
   { "aaaa", "http://aaaa/?aaaa=1&b={searchTerms}&c", "aaaa" },
   { "aaaaa", "{searchTerms}", "aaaaa" },
   { "ab", "bogus URL {searchTerms}", "ab" },
   { "weasel", "weasel{searchTerms}weasel", "weasel" },
   { "www", " +%2B?={searchTerms}foo ", "www" },
   { "nonsub", "http://nonsubstituting-keyword.com/", "nonsub" },
   { "z", "{searchTerms}=z", "z" },
 };
 
 void KeywordProviderTest::SetUp() {
-  model_.reset(new TemplateURLService(kTestData, arraysize(kTestData)));
-  kw_provider_ = new KeywordProvider(NULL, model_.get());
+  scoped_ptr<TemplateURLService> template_url_service(
+      new TemplateURLService(kTestData, arraysize(kTestData)));
+  client_.reset(new MockAutocompleteProviderClient());
+  client_->set_template_url_service(template_url_service.Pass());
+  kw_provider_ = new KeywordProvider(client_.get(), nullptr);
 }
 
 void KeywordProviderTest::TearDown() {
-  model_.reset();
+  client_.reset();
   kw_provider_ = NULL;
 }
 
 template<class ResultType>
 void KeywordProviderTest::RunTest(TestData<ResultType>* keyword_cases,
                                   int num_cases,
                                   ResultType AutocompleteMatch::* member) {
   ACMatches matches;
   for (int i = 0; i < num_cases; ++i) {
     SCOPED_TRACE(keyword_cases[i].input);
@@ skipping 171 matching lines @@
                     &AutocompleteMatch::contents);
 }
 
 TEST_F(KeywordProviderTest, AddKeyword) {
   TemplateURLData data;
   data.SetShortName(ASCIIToUTF16("Test"));
   base::string16 keyword(ASCIIToUTF16("foo"));
   data.SetKeyword(keyword);
   data.SetURL("http://www.google.com/foo?q={searchTerms}");
   TemplateURL* template_url = new TemplateURL(data);
-  model_->Add(template_url);
-  ASSERT_TRUE(template_url == model_->GetTemplateURLForKeyword(keyword));
+  client_->GetTemplateURLService()->Add(template_url);
+  ASSERT_TRUE(
+      template_url ==
+      client_->GetTemplateURLService()->GetTemplateURLForKeyword(keyword));
 }
 
 TEST_F(KeywordProviderTest, RemoveKeyword) {
+  TemplateURLService* template_url_service = client_->GetTemplateURLService();
   base::string16 url(ASCIIToUTF16("http://aaaa/?aaaa=1&b={searchTerms}&c"));
-  model_->Remove(model_->GetTemplateURLForKeyword(ASCIIToUTF16("aaaa")));
-  ASSERT_TRUE(model_->GetTemplateURLForKeyword(ASCIIToUTF16("aaaa")) == NULL);
+  template_url_service->Remove(
+      template_url_service->GetTemplateURLForKeyword(ASCIIToUTF16("aaaa")));
+  ASSERT_TRUE(template_url_service->GetTemplateURLForKeyword(
+                  ASCIIToUTF16("aaaa")) == NULL);
 }
 
 TEST_F(KeywordProviderTest, GetKeywordForInput) {
   EXPECT_EQ(ASCIIToUTF16("aa"),
       kw_provider_->GetKeywordForText(ASCIIToUTF16("aa")));
   EXPECT_EQ(base::string16(),
       kw_provider_->GetKeywordForText(ASCIIToUTF16("aafoo")));
   EXPECT_EQ(base::string16(),
       kw_provider_->GetKeywordForText(ASCIIToUTF16("aa foo")));
 }
@@ skipping 39 matching lines @@
     { "aa foo", base::string16::npos, false, "", "aa foo",
       base::string16::npos },
   };
   for (size_t i = 0; i < arraysize(cases); i++) {
     AutocompleteInput input(ASCIIToUTF16(cases[i].text),
                             cases[i].cursor_position, std::string(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, cases[i].allow_exact_keyword_match, true,
                             false, TestingSchemeClassifier());
     const TemplateURL* url =
-        KeywordProvider::GetSubstitutingTemplateURLForInput(model_.get(),
-                                                            &input);
+        KeywordProvider::GetSubstitutingTemplateURLForInput(
+            client_->GetTemplateURLService(), &input);
     if (cases[i].expected_url.empty())
       EXPECT_FALSE(url);
     else
       EXPECT_EQ(cases[i].expected_url, url->url());
     EXPECT_EQ(ASCIIToUTF16(cases[i].updated_text), input.text());
     EXPECT_EQ(cases[i].updated_cursor_position, input.cursor_position());
   }
 }
 
 // If extra query params are specified on the command line, they should be
@@ skipping 14 matching lines @@
 }
 
 TEST_F(KeywordProviderTest, DoesNotProvideMatchesOnFocus) {
   AutocompleteInput input(ASCIIToUTF16("aaa"), base::string16::npos,
                           std::string(), GURL(),
                           metrics::OmniboxEventProto::INVALID_SPEC, true, false,
                           true, true, true, TestingSchemeClassifier());
   kw_provider_->Start(input, false);
   ASSERT_TRUE(kw_provider_->matches().empty());
 }