Omnibox: Reduce Bolding Flicker in SearchProvider

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 256 matching lines @@
     field_trial_triggered_ |= triggered;
     field_trial_triggered_in_session_ |= triggered;
   }
 
   // Clear the previous results now that new results are available.
   suggest_results->clear();
   navigation_results->clear();
 
   string16 result, title;
   std::string type;
+  const string16 current_query_str16 = ASCIIToUTF16(current_query_);

[msw, 2013/08/26 22:57:15]

Drop "_str16", use "_string" or "_string16" if you must.

+  const std::string languages =
+      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
   for (size_t index = 0; results->GetString(index, &result); ++index) {
     // Google search may return empty suggestions for weird input characters,
     // they make no sense at all and can cause problems in our code.
     if (result.empty())
       continue;
 
     int relevance = kDefaultZeroSuggestRelevance;
 
     // 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(UTF16ToUTF8(result), std::string()));
       if (url.is_valid()) {
         if (descriptions != NULL)
           descriptions->GetString(index, &title);
         navigation_results->push_back(SearchProvider::NavigationResult(
-            *this, url, title, false, relevance, relevances != NULL));
+            *this, url, title, false, relevance, relevances != NULL,
+            current_query_str16, languages));
       }
     } else {
       suggest_results->push_back(SearchProvider::SuggestResult(
-          result, false, relevance, relevances != NULL));
+          result, false, relevance, relevances != NULL, current_query_str16));
     }
   }
 }
 
 void ZeroSuggestProvider::AddSuggestResultsToMap(
     const SearchProvider::SuggestResults& results,
     const TemplateURL* template_url,
     SearchProvider::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);
+    AddMatchToMap(results[i], AutocompleteMatchType::SEARCH_SUGGEST,
+                  template_url, i, map);
   }
 }
 
-void ZeroSuggestProvider::AddMatchToMap(int relevance,
-                                        AutocompleteMatch::Type type,
-                                        const TemplateURL* template_url,
-                                        const string16& query_string,
-                                        int accepted_suggestion,
-                                        SearchProvider::MatchMap* map) {
-  // Pass in query_string as the input_text since we don't want any bolding.
+void ZeroSuggestProvider::AddMatchToMap(
+    const SearchProvider::SuggestResult& result,
+    AutocompleteMatch::Type type,
+    const TemplateURL* template_url,
+    int accepted_suggestion,
+    SearchProvider::MatchMap* map) {
+  // Pass in result.suggestion() as the input_text since we don't want any

[msw, 2013/08/26 22:57:15]

nit: "to avoid bolding"

+  // bolding.
   // TODO(samarth|melevin): use the actual omnibox margin here as well instead
   // of passing in -1.
   AutocompleteMatch match = SearchProvider::CreateSearchSuggestion(
-      this, relevance, type, template_url, query_string, query_string,
-      AutocompleteInput(), false, accepted_suggestion, -1, true);
+      this, result, type, template_url, result.suggestion(),
+      AutocompleteInput(), 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.
+  // Try to add |match| to |map|.  If a match for |result.suggestion()| is
+  // already in |map|, replace it if |match| is more relevant.
   // NOTE: Keep this ToLower() call in sync with url_database.cc.
   const std::pair<SearchProvider::MatchMap::iterator, bool> i(map->insert(
-      std::make_pair(base::i18n::ToLower(query_string), match)));
+      std::make_pair(base::i18n::ToLower(result.suggestion()), 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) {
   AutocompleteMatch match(this, navigation.relevance(), false,
                           AutocompleteMatchType::NAVSUGGEST);
   match.destination_url = navigation.url();
 
+  // We ignore navigation.contents() and navigation.contents_class()

[msw, 2013/08/26 22:57:15]

nit: "Zero suggest results should always omit protocols and never appear bold."

+  // and instead compute our own contents and contents_class
+  // because we want a uniform style of display in zero suggest:
+  // - no bolding of URLs (it doesn't matter if the URL shares a prefix with
+  //   the current URL).
+  // - always omit the protocol.
   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 +=
       AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url(),
           match.contents);
 
   AutocompleteMatch::ClassifyLocationInString(string16::npos, 0,
       match.contents.length(), ACMatchClassification::URL,
@@ skipping 104 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;
 }