Part 1 of search provider refactoring.

chrome/browser/autocomplete/zero_suggest_provider.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 "chrome/browser/autocomplete/zero_suggest_provider.h"
 
 #include "base/callback.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/metrics/histogram.h"
@@ skipping 165 matching lines @@
   done_ = false;
   // TODO(jered): Consider adding locally-sourced zero-suggestions here too.
   // These may be useful on the NTP or more relevant to the user than server
   // suggestions, if based on local browsing history.
   Run(suggest_url);
 }
 
 ZeroSuggestProvider::ZeroSuggestProvider(
   AutocompleteProviderListener* listener,
   Profile* profile)
-    : AutocompleteProvider(listener, profile,
-          AutocompleteProvider::TYPE_ZERO_SUGGEST),
+    : BaseSearchProvider(listener, profile,
+                         AutocompleteProvider::TYPE_ZERO_SUGGEST),
       template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
       have_pending_request_(false),
       verbatim_relevance_(kDefaultVerbatimZeroSuggestRelevance),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false),
       weak_ptr_factory_(this) {
 }
 
 ZeroSuggestProvider::~ZeroSuggestProvider() {
 }
 
-void ZeroSuggestProvider::FillResults(
-    const base::Value& root_val,
-    int* verbatim_relevance,
-    SearchProvider::SuggestResults* suggest_results,
-    SearchProvider::NavigationResults* navigation_results) {
+void ZeroSuggestProvider::FillResults(const base::Value& root_val,
+                                      int* verbatim_relevance,
+                                      SuggestResults* suggest_results,
+                                      NavigationResults* navigation_results) {
   base::string16 query;
   const base::ListValue* root_list = NULL;
   const base::ListValue* results = NULL;
   const base::ListValue* relevances = NULL;
   // The response includes the query, which should be empty for ZeroSuggest
   // responses.
   if (!root_val.GetAsList(&root_list) || !root_list->GetString(0, &query) ||
       (!query.empty()) || !root_list->GetList(1, &results))
     return;
 
@@ skipping 46 matching lines @@
     // Apply valid suggested relevance scores; discard invalid lists.
     if (relevances != NULL && !relevances->GetInteger(index, &relevance))
       relevances = NULL;
     if (types && types->GetString(index, &type) && (type == "NAVIGATION")) {
       // Do not blindly trust the URL coming from the server to be valid.
       GURL url(URLFixerUpper::FixupURL(
           base::UTF16ToUTF8(result), std::string()));
       if (url.is_valid()) {
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
-        navigation_results->push_back(SearchProvider::NavigationResult(
+        navigation_results->push_back(NavigationResult(
             *this, url, title, false, relevance, relevances != NULL,
             current_query_string16, languages));
       }
     } else {
-      suggest_results->push_back(SearchProvider::SuggestResult(
+      suggest_results->push_back(SuggestResult(
           result, AutocompleteMatchType::SEARCH_SUGGEST, result,
           base::string16(), std::string(), std::string(), false, relevance,
           relevances != NULL, false, current_query_string16));
     }
   }
 }
 
 void ZeroSuggestProvider::AddSuggestResultsToMap(
-    const SearchProvider::SuggestResults& results,
+    const SuggestResults& results,
     const TemplateURL* template_url,
-    SearchProvider::MatchMap* map) {
+    MatchMap* map) {
   for (size_t i = 0; i < results.size(); ++i) {
     AddMatchToMap(results[i].relevance(), AutocompleteMatchType::SEARCH_SUGGEST,
                   template_url, results[i].suggestion(), i, map);
   }
 }
 
 void ZeroSuggestProvider::AddMatchToMap(int relevance,
                                         AutocompleteMatch::Type type,
                                         const TemplateURL* template_url,
                                         const base::string16& query_string,
                                         int accepted_suggestion,
-                                        SearchProvider::MatchMap* map) {
+                                        MatchMap* map) {
   // Pass in query_string as the input_text to avoid bolding.
-  SearchProvider::SuggestResult suggestion(
+  SuggestResult suggestion(
       query_string, type, query_string, base::string16(), std::string(),
       std::string(), false, relevance, true, false, query_string);
   // TODO(samarth|melevin): use the actual omnibox margin here as well instead
   // of passing in -1.
   AutocompleteMatch match = SearchProvider::CreateSearchSuggestion(
       this, AutocompleteInput(), query_string, suggestion, template_url,
       accepted_suggestion, -1, true);
   if (!match.destination_url.is_valid())
     return;
 
   // Try to add |match| to |map|.  If a match for |query_string| is already in
   // |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
-  SearchProvider::MatchKey match_key(
+  MatchKey match_key(
       std::make_pair(base::i18n::ToLower(query_string), std::string()));
-  const std::pair<SearchProvider::MatchMap::iterator, bool> i(map->insert(
+  const std::pair<MatchMap::iterator, bool> i(map->insert(
       std::make_pair(match_key, match)));
   // NOTE: We purposefully do a direct relevance comparison here instead of
   // using AutocompleteMatch::MoreRelevant(), so that we'll prefer "items added
   // first" rather than "items alphabetically first" when the scores are equal.
   // The only case this matters is when a user has results with the same score
   // that differ only by capitalization; because the history system returns
   // results sorted by recency, this means we'll pick the most recent such
   // result even if the precision of our relevance score is too low to
   // distinguish the two.
   if (!i.second && (match.relevance > i.first->second.relevance))
     i.first->second = match;
 }
 
 AutocompleteMatch ZeroSuggestProvider::NavigationToMatch(
-    const SearchProvider::NavigationResult& navigation) {
+    const NavigationResult& navigation) {
   AutocompleteMatch match(this, navigation.relevance(), false,
                           AutocompleteMatchType::NAVSUGGEST);
   match.destination_url = navigation.url();
 
   // Zero suggest results should always omit protocols and never appear bold.
   const std::string languages(
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
   match.contents = net::FormatUrl(navigation.url(), languages,
       net::kFormatUrlOmitAll, net::UnescapeRule::SPACES, NULL, NULL, NULL);
   match.fill_into_edit +=
@@ skipping 36 matching lines @@
       ts->GetMostVisitedURLs(
           base::Bind(&ZeroSuggestProvider::OnMostVisitedUrlsAvailable,
                      weak_ptr_factory_.GetWeakPtr()), false);
     }
   }
   have_pending_request_ = true;
   LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_SENT);
 }
 
 void ZeroSuggestProvider::ParseSuggestResults(const base::Value& root_val) {
-  SearchProvider::SuggestResults suggest_results;
+  SuggestResults suggest_results;
   FillResults(root_val, &verbatim_relevance_,
               &suggest_results, &navigation_results_);
 
   query_matches_map_.clear();
   AddSuggestResultsToMap(suggest_results,
                          template_url_service_->GetDefaultSearchProvider(),
                          &query_matches_map_);
 }
 
 void ZeroSuggestProvider::OnMostVisitedUrlsAvailable(
@@ skipping 27 matching lines @@
       UMA_HISTOGRAM_COUNTS(
           "Omnibox.ZeroSuggest.MostVisitedResultsCounterfactual",
           most_visited_urls_.size());
     }
     const base::string16 current_query_string16(
         base::ASCIIToUTF16(current_query_));
     const std::string languages(
         profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
     for (size_t i = 0; i < most_visited_urls_.size(); i++) {
       const history::MostVisitedURL& url = most_visited_urls_[i];
-      SearchProvider::NavigationResult nav(
-          *this, url.url, url.title, false, relevance, true,
+      NavigationResult nav(*this, url.url, url.title, false, relevance, true,
           current_query_string16, languages);
       matches_.push_back(NavigationToMatch(nav));
       --relevance;
     }
     return;
   }
 
   if (num_results == 0)
     return;
 
   // TODO(jered): Rip this out once the first match is decoupled from the
   // current typing in the omnibox.
   matches_.push_back(current_url_match_);
 
-  for (SearchProvider::MatchMap::const_iterator it(query_matches_map_.begin());
+  for (MatchMap::const_iterator it(query_matches_map_.begin());
        it != query_matches_map_.end(); ++it)
     matches_.push_back(it->second);
 
-  for (SearchProvider::NavigationResults::const_iterator it(
-       navigation_results_.begin()); it != navigation_results_.end(); ++it)
+  for (NavigationResults::const_iterator it(navigation_results_.begin());
+       it != navigation_results_.end(); ++it)
     matches_.push_back(NavigationToMatch(*it));
 }
 
 AutocompleteMatch ZeroSuggestProvider::MatchForCurrentURL() {
   AutocompleteInput input(permanent_text_, base::string16::npos, base::string16(),
                           GURL(current_query_), current_page_classification_,
                           false, false, true, AutocompleteInput::ALL_MATCHES);
 
   AutocompleteMatch match;
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(
       permanent_text_, false, true, &match, NULL);
   match.is_history_what_you_typed_match = false;
   match.allowed_to_be_default_match = true;
 
   // The placeholder suggestion for the current URL has high relevance so
   // that it is in the first suggestion slot and inline autocompleted. It
   // gets dropped as soon as the user types something.
   match.relevance = verbatim_relevance_;
 
   return match;
 }