Part 4 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 157 matching lines @@
                          AutocompleteProvider::TYPE_ZERO_SUGGEST),
       template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
       have_pending_request_(false),
       verbatim_relevance_(kDefaultVerbatimZeroSuggestRelevance),
       weak_ptr_factory_(this) {
 }
 
 ZeroSuggestProvider::~ZeroSuggestProvider() {
 }
 
+const TemplateURL* ZeroSuggestProvider::GetTemplateURL(
+    const SuggestResult& result) const {
+  // Zero suggest provider should not receive keyword results.
+  DCHECK(!result.from_keyword_provider());
+  return template_url_service_->GetDefaultSearchProvider();
+}
+
+const AutocompleteInput ZeroSuggestProvider::GetInput(
+    const SuggestResult& result) const {
+  AutocompleteInput input;
+  // Set |input|'s text to be |query_string| to avoid bolding.
+  input.UpdateText(base::string16(result.suggestion()),

[msw, 2014/02/13 23:27:54]

nit: I don't think you need to construct a string16 copy here.

[Maria, 2014/02/13 23:38:01]

Oops. You are right! Done.

+                   base::string16::npos, input.parts());
+  return input;
+}
+
+bool ZeroSuggestProvider::ShouldAppendExtraParams(
+      const SuggestResult& result) const {
+  // We always use the default provider for search, so append the params.
+  return true;
+}
+
 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.
@@ skipping 65 matching lines @@
       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 SuggestResults& results,
-    const TemplateURL* template_url,
     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);
+    const base::string16& query_string(results[i].suggestion());
+    // TODO(mariakhomenko): Do not reconstruct SuggestResult objects with
+    // a different query -- create correct objects to begin with.
+    const SuggestResult suggestion(
+        query_string, AutocompleteMatchType::SEARCH_SUGGEST, query_string,
+        base::string16(), std::string(), std::string(), false,
+        results[i].relevance(), true, false, query_string);
+    AddMatchToMap(suggestion, std::string(), i, map);
   }
 }
 
-void ZeroSuggestProvider::AddMatchToMap(int relevance,
-                                        AutocompleteMatch::Type type,
-                                        const TemplateURL* template_url,
-                                        const base::string16& query_string,
-                                        int accepted_suggestion,
-                                        MatchMap* map) {
-  // Pass in query_string as the input_text to avoid bolding.
-  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 = 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.
-  MatchKey match_key(
-      std::make_pair(base::i18n::ToLower(query_string), std::string()));
-  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 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,
@@ skipping 43 matching lines @@
   have_pending_request_ = true;
   LogOmniboxZeroSuggestRequest(ZERO_SUGGEST_REQUEST_SENT);
 }
 
 void ZeroSuggestProvider::ParseSuggestResults(const base::Value& root_val) {
   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_);
+  AddSuggestResultsToMap(suggest_results, &query_matches_map_);
 }
 
 void ZeroSuggestProvider::OnMostVisitedUrlsAvailable(
     const history::MostVisitedURLList& urls) {
   most_visited_urls_ = urls;
 }
 
 void ZeroSuggestProvider::ConvertResultsToAutocompleteMatches() {
   matches_.clear();
 
@@ skipping 62 matching lines @@
   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;
 }