Prepare HistoryProvider for componentization

components/omnibox/base_search_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 "components/omnibox/base_search_provider.h"
 
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/omnibox/autocomplete_match.h"
 #include "components/omnibox/autocomplete_match_type.h"
@@ skipping 13 matching lines @@
 
 class MockAutocompleteProviderClient : public AutocompleteProviderClient {
  public:
   MockAutocompleteProviderClient() {}
   MOCK_METHOD0(RequestContext, net::URLRequestContextGetter*());
   MOCK_METHOD0(IsOffTheRecord, bool());
   MOCK_METHOD0(AcceptLanguages, std::string());
   MOCK_METHOD0(SearchSuggestEnabled, bool());
   MOCK_METHOD0(ShowBookmarkBar, bool());
   MOCK_METHOD0(SchemeClassifier, const AutocompleteSchemeClassifier&());
+  MOCK_METHOD0(HistoryService, history::HistoryService*());
+  MOCK_METHOD0(BookmarkModel, bookmarks::BookmarkModel*());
   MOCK_METHOD6(
       Classify,
       void(const base::string16& text,
            bool prefer_keyword,
            bool allow_exact_keyword_match,
            metrics::OmniboxEventProto::PageClassification page_classification,
            AutocompleteMatch* match,
            GURL* alternate_nav_url));
   MOCK_METHOD0(InMemoryDatabase, history::URLDatabase*());
   MOCK_METHOD2(DeleteMatchingURLsForKeywordFromHistory,
                void(history::KeywordID keyword_id, const base::string16& term));
   MOCK_METHOD0(TabSyncEnabledAndUnencrypted, bool());
   MOCK_METHOD1(PrefetchImage, void(const GURL& url));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAutocompleteProviderClient);
 };
 
 class TestBaseSearchProvider : public BaseSearchProvider {
  public:
   typedef BaseSearchProvider::MatchMap MatchMap;
 
-  // Note: Takes ownership of client. scoped_ptr<> would be the right way to
-  // express that, but NiceMock<> can't forward a scoped_ptr.
-  TestBaseSearchProvider(TemplateURLService* template_url_service,
+  TestBaseSearchProvider(AutocompleteProvider::Type type,
                          AutocompleteProviderClient* client,
-                         AutocompleteProvider::Type type)
-      : BaseSearchProvider(template_url_service,
-                           scoped_ptr<AutocompleteProviderClient>(client),
-                           type) {}
+                         TemplateURLService* template_url_service)
+      : BaseSearchProvider(type, client, template_url_service) {}
   MOCK_METHOD1(DeleteMatch, void(const AutocompleteMatch& match));
   MOCK_CONST_METHOD1(AddProviderInfo, void(ProvidersInfo* provider_info));
   MOCK_CONST_METHOD1(GetTemplateURL, const TemplateURL*(bool is_keyword));
   MOCK_CONST_METHOD1(GetInput, const AutocompleteInput(bool is_keyword));
   MOCK_CONST_METHOD1(ShouldAppendExtraParams,
                      bool(const SearchSuggestionParser::SuggestResult& result));
   MOCK_METHOD1(RecordDeletionResult, void(bool success));
 
   MOCK_METHOD3(Start,
                void(const AutocompleteInput& input, bool minimal_changes,
@@ skipping 26 matching lines @@
  protected:
   void SetUp() override {
     service_.reset(
         new TemplateURLService(NULL,
                                scoped_ptr<SearchTermsData>(new SearchTermsData),
                                NULL,
                                scoped_ptr<TemplateURLServiceClient>(),
                                NULL,
                                NULL,
                                base::Closure()));
+    client_.reset(new NiceMock<MockAutocompleteProviderClient>());
     provider_ = new NiceMock<TestBaseSearchProvider>(
-        service_.get(),
-        new NiceMock<MockAutocompleteProviderClient>,
-        AutocompleteProvider::TYPE_SEARCH);
+        AutocompleteProvider::TYPE_SEARCH, client_.get(), service_.get());
   }
 
   scoped_refptr<NiceMock<TestBaseSearchProvider> > provider_;
   scoped_ptr<TemplateURLService> service_;
+  scoped_ptr<NiceMock<MockAutocompleteProviderClient>> client_;
 };
 
 TEST_F(BaseSearchProviderTest, PreserveAnswersWhenDeduplicating) {
   TemplateURLData data;
   data.SetURL("http://foo.com/url?bar={searchTerms}");
   scoped_ptr<TemplateURL> template_url(new TemplateURL(data));
 
   TestBaseSearchProvider::MatchMap map;
   base::string16 query = base::ASCIIToUTF16("weather los angeles");
   base::string16 answer_contents = base::ASCIIToUTF16("some answer content");
@@ skipping 67 matching lines @@
   EXPECT_TRUE(answer2->Equals(*match.answer));
   EXPECT_EQ(AutocompleteMatchType::SEARCH_HISTORY, match.type);
   EXPECT_EQ(1300, match.relevance);
 
   EXPECT_EQ(answer_contents, duplicate.answer_contents);
   EXPECT_EQ(answer_type, duplicate.answer_type);
   EXPECT_TRUE(answer->Equals(*duplicate.answer));
   EXPECT_EQ(AutocompleteMatchType::SEARCH_SUGGEST, duplicate.type);
   EXPECT_EQ(850, duplicate.relevance);
 }