Omnibox: Reduce Bolding Flicker in SearchProvider

chrome/browser/autocomplete/search_provider.cc

 // Copyright 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/search_provider.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/callback.h"
@@ skipping 79 matching lines @@
       if (i.IsWord()) {
         if (found_word)
           return true;
         found_word = true;
       }
     }
   }
   return false;
 }
 
+// When displaying a match for |formatted_url| against omnibox input
+// |input_text|, determine:
+// * if Chrome should strip the http scheme
+// * where |input_text| matches in |formatted_url| (if it does)
+// * where |input_text| matches as an inline autocompletion in |formatted_url_|
+//   (if it does)
+void GetTrimHttpAndOffsets(const string16& formatted_url,
+                           const string16& input_text,
+                           bool* trim_http,
+                           size_t* match_start,
+                           size_t* inline_autocomplete_offset) {
+  // Look for the user's input inside the formatted_url as it would be without

[Mark P, 2013/08/16 23:25:58]

This logic was moved here from NavigationToMatch().

+  // trimming the scheme, so we can find matches at the beginning of the
+  // scheme.
+  const URLPrefix* prefix = URLPrefix::BestURLPrefix(formatted_url, input_text);
+  (*match_start) = (prefix == NULL) ?
+      formatted_url.find(input_text) : prefix->prefix.length();
+  (*trim_http) = !AutocompleteProvider::HasHTTPScheme(input_text) &&
+      (!prefix || (match_start != 0));
+  (*inline_autocomplete_offset) = (prefix == NULL) ?
+      string16::npos : (*match_start + input_text.length());
+}
+
 }  // namespace
 
 
 // SearchProvider::Providers --------------------------------------------------
 
 SearchProvider::Providers::Providers(TemplateURLService* template_url_service)
     : template_url_service_(template_url_service) {
 }
 
 const TemplateURL* SearchProvider::Providers::GetDefaultProviderURL() const {
@@ skipping 16 matching lines @@
       relevance_(relevance),
       relevance_from_server_(relevance_from_server) {
 }
 
 SearchProvider::Result::~Result() {
 }
 
 
 // SearchProvider::SuggestResult ----------------------------------------------
 
-SearchProvider::SuggestResult::SuggestResult(const string16& suggestion,
-                                             bool from_keyword_provider,
-                                             int relevance,
-                                             bool relevance_from_server)
+SearchProvider::SuggestResult::SuggestResult(
+    const string16& suggestion,
+    bool from_keyword_provider,
+    int relevance,
+    bool relevance_from_server,
+    const string16& input_text)
     : Result(from_keyword_provider, relevance, relevance_from_server),
       suggestion_(suggestion) {
+  CalculateContents(true, input_text);
 }
 
 SearchProvider::SuggestResult::~SuggestResult() {
 }
 
 bool SearchProvider::SuggestResult::IsInlineable(const string16& input) const {
   return StartsWith(suggestion_, input, false);
 }
 
 int SearchProvider::SuggestResult::CalculateRelevance(
     const AutocompleteInput& input,
     bool keyword_provider_requested) const {
   if (!from_keyword_provider_ && keyword_provider_requested)
     return 100;
   return ((input.type() == AutocompleteInput::URL) ? 300 : 600);
 }
 
+void SearchProvider::SuggestResult::CalculateContents(

[Mark P, 2013/08/16 23:25:58]

This is still basically a cut-and-paste from CreateSearchSuggestion, with the
change to handle allow_bolding_all and also a replacement of match.contents to
contents_ and match.contents_class to contents_class_.

+    bool allow_bolding_all,
+    const string16& input_text) {
+  size_t input_position = suggestion_.find(input_text);
+  if (!allow_bolding_all && (input_text != suggestion_) &&
+      (input_position == string16::npos)) {
+    // Bail if the code below to update the bolding would bold the whole
+    // string.  Note that the string may already be entirely bolded; if
+    // so, leave it as is.
+    return;
+  }
+  contents_.assign(suggestion_);
+  contents_class_.clear();
+  // We do intra-string highlighting for suggestions - the suggested segment
+  // will be highlighted, e.g. for input_text = "you" the suggestion may be
+  // "youtube", so we'll bold the "tube" section: you*tube*.
+  if (input_text != suggestion_) {
+    if (input_position == string16::npos) {
+      // The input text is not a substring of the query string, e.g. input
+      // text is "slasdot" and the query string is "slashdot", so we bold the
+      // whole thing.
+      contents_class_.push_back(
+          ACMatchClassification(0, ACMatchClassification::MATCH));
+    } else {
+      // TODO(beng): ACMatchClassification::MATCH now seems to just mean
+      //             "bold" this. Consider modifying the terminology.
+      // We don't iterate over the string here annotating all matches because
+      // it looks odd to have every occurrence of a substring that may be as
+      // short as a single character highlighted in a query suggestion result,
+      // e.g. for input text "s" and query string "southwest airlines", it
+      // looks odd if both the first and last s are highlighted.
+      if (input_position != 0) {
+        contents_class_.push_back(
+            ACMatchClassification(0, ACMatchClassification::MATCH));
+      }
+      contents_class_.push_back(
+          ACMatchClassification(input_position, ACMatchClassification::NONE));
+      size_t next_fragment_position = input_position + input_text.length();
+      if (next_fragment_position < suggestion_.length()) {
+        contents_class_.push_back(
+            ACMatchClassification(next_fragment_position,
+                                  ACMatchClassification::MATCH));
+      }
+    }
+  } else {
+    // Otherwise, |match| is a verbatim (what-you-typed) match, either for the
+    // default provider or a keyword search provider.
+    contents_class_.push_back(
+        ACMatchClassification(0, ACMatchClassification::NONE));
+
+  }
+}
 
 // SearchProvider::NavigationResult -------------------------------------------
 
 SearchProvider::NavigationResult::NavigationResult(
     const AutocompleteProvider& provider,
     const GURL& url,
     const string16& description,
     bool from_keyword_provider,
     int relevance,
-    bool relevance_from_server)
+    bool relevance_from_server,
+    const string16& input_text,
+    const std::string& languages)
     : Result(from_keyword_provider, relevance, relevance_from_server),
       url_(url),
       formatted_url_(AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url, provider.StringForURLDisplay(url, true, false))),
       description_(description) {
   DCHECK(url_.is_valid());
+  CalculateContents(true, input_text, languages);
 }
 
 SearchProvider::NavigationResult::~NavigationResult() {
 }
 
 bool SearchProvider::NavigationResult::IsInlineable(
     const string16& input) const {
   return URLPrefix::BestURLPrefix(formatted_url_, input) != NULL;
 }
 
 int SearchProvider::NavigationResult::CalculateRelevance(
     const AutocompleteInput& input,
     bool keyword_provider_requested) const {
   return (from_keyword_provider_ || !keyword_provider_requested) ? 800 : 150;
 }
 
+void SearchProvider::NavigationResult::CalculateContents(
+    bool allow_bolding_nothing,
+    const string16& input_text,
+    const std::string languages) {
+  bool trim_http;
+  size_t match_start, inline_autocomplete_offset;
+  GetTrimHttpAndOffsets(formatted_url_, input_text, &trim_http, &match_start,
+                        &inline_autocomplete_offset);
+  if (!allow_bolding_nothing && (match_start == string16::npos)) {
+    // Bail if the code below to update the bolding would make the stirng
+    // entirely not bolded.  Note that the string may already be entirely
+    // not bolded; if so, leave it as is.
+    return;
+  }
+  const net::FormatUrlTypes format_types =

[Mark P, 2013/08/16 23:25:58]

This logic here and below was moved here from NavigationToMatch().

+      net::kFormatUrlOmitAll & ~(trim_http ? 0 : net::kFormatUrlOmitHTTP);
+  contents_ = net::FormatUrl(url_, languages,
+      format_types, net::UnescapeRule::SPACES, NULL, NULL, &match_start);
+  // If the first match in the untrimmed string was inside a scheme that we
+  // trimmed, look for a subsequent match.
+  if (match_start == string16::npos)
+    match_start = contents_.find(input_text);
+  // Safe if |match_start| is npos; also safe if the input is longer than the
+  // remaining contents after |match_start|.
+  AutocompleteMatch::ClassifyLocationInString(match_start, input_text.length(),
+      contents_.length(), ACMatchClassification::URL,
+      &contents_class_);
+}
 
 // SearchProvider::CompareScoredResults ---------------------------------------
 
 class SearchProvider::CompareScoredResults {
  public:
   bool operator()(const Result& a, const Result& b) {
     // Sort in descending relevance order.
     return a.relevance() > b.relevance();
   }
 };
@@ skipping 49 matching lines @@
                                Profile* profile)
     : AutocompleteProvider(listener, profile,
           AutocompleteProvider::TYPE_SEARCH),
       providers_(TemplateURLServiceFactory::GetForProfile(profile)),
       suggest_results_pending_(0),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false) {
 }
 
 // static
 AutocompleteMatch SearchProvider::CreateSearchSuggestion(

[Mark P, 2013/08/16 23:25:58]

When this review is almost complete, I will move this to the right place in this
file according to header order.  I've left it as is for the moment for ease of
review.

     AutocompleteProvider* autocomplete_provider,
-    int relevance,
+    const SuggestResult& result,
     AutocompleteMatch::Type type,
     const TemplateURL* template_url,
-    const string16& query_string,
     const string16& input_text,
     const AutocompleteInput& input,
-    bool is_keyword,
     int accepted_suggestion,
     int omnibox_start_margin,
     bool append_extra_query_params) {
-  AutocompleteMatch match(autocomplete_provider, relevance, false, type);
+  AutocompleteMatch match(
+      autocomplete_provider, result.relevance(), false, type);
 
   if (!template_url)
     return match;
   match.keyword = template_url->keyword();
 
-  match.contents.assign(query_string);
-  // We do intra-string highlighting for suggestions - the suggested segment
-  // will be highlighted, e.g. for input_text = "you" the suggestion may be
-  // "youtube", so we'll bold the "tube" section: you*tube*.
-  if (input_text != query_string) {
-    size_t input_position = match.contents.find(input_text);
-    if (input_position == string16::npos) {
-      // The input text is not a substring of the query string, e.g. input
-      // text is "slasdot" and the query string is "slashdot", so we bold the
-      // whole thing.
-      match.contents_class.push_back(
-          ACMatchClassification(0, ACMatchClassification::MATCH));
-    } else {
-      // TODO(beng): ACMatchClassification::MATCH now seems to just mean
-      //             "bold" this. Consider modifying the terminology.
-      // We don't iterate over the string here annotating all matches because
-      // it looks odd to have every occurrence of a substring that may be as
-      // short as a single character highlighted in a query suggestion result,
-      // e.g. for input text "s" and query string "southwest airlines", it
-      // looks odd if both the first and last s are highlighted.
-      if (input_position != 0) {
-        match.contents_class.push_back(
-            ACMatchClassification(0, ACMatchClassification::MATCH));
-      }
-      match.contents_class.push_back(
-          ACMatchClassification(input_position, ACMatchClassification::NONE));
-      size_t next_fragment_position = input_position + input_text.length();
-      if (next_fragment_position < query_string.length()) {
-        match.contents_class.push_back(
-            ACMatchClassification(next_fragment_position,
-                                  ACMatchClassification::MATCH));
-      }
-    }
-  } else {
-    // Otherwise, |match| is a verbatim (what-you-typed) match, either for the
-    // default provider or a keyword search provider.
-    match.contents_class.push_back(
-        ACMatchClassification(0, ACMatchClassification::NONE));
+  match.contents = result.contents();
+  match.contents_class = result.contents_class();
+  if (input_text == result.suggestion())
     match.allowed_to_be_default_match = true;
-  }
 
   // When the user forced a query, we need to make sure all the fill_into_edit
   // values preserve that property.  Otherwise, if the user starts editing a
   // suggestion, non-Search results will suddenly appear.
   if (input.type() == AutocompleteInput::FORCED_QUERY)
     match.fill_into_edit.assign(ASCIIToUTF16("?"));
-  if (is_keyword)
+  if (result.from_keyword_provider())
     match.fill_into_edit.append(match.keyword + char16(' '));
   if (!input.prevent_inline_autocomplete() &&
-      StartsWith(query_string, input_text, false)) {
-    match.inline_autocompletion = query_string.substr(input_text.length());
+      StartsWith(result.suggestion(), input_text, false)) {
+    match.inline_autocompletion =
+        result.suggestion().substr(input_text.length());
     match.allowed_to_be_default_match = true;
   }
-  match.fill_into_edit.append(query_string);
+  match.fill_into_edit.append(result.suggestion());
 
   const TemplateURLRef& search_url = template_url->url_ref();
   DCHECK(search_url.SupportsReplacement());
   match.search_terms_args.reset(
-      new TemplateURLRef::SearchTermsArgs(query_string));
+      new TemplateURLRef::SearchTermsArgs(result.suggestion()));
   match.search_terms_args->original_query = input_text;
   match.search_terms_args->accepted_suggestion = accepted_suggestion;
   match.search_terms_args->omnibox_start_margin = omnibox_start_margin;
   match.search_terms_args->append_extra_query_params =
       append_extra_query_params;
   // This is the destination URL sans assisted query stats.  This must be set
   // so the AutocompleteController can properly de-dupe; the controller will
   // eventually overwrite it before it reaches the user.
   match.destination_url =
       GURL(search_url.ReplaceSearchTerms(*match.search_terms_args.get()));
 
   // Search results don't look like URLs.
-  match.transition = is_keyword ?
+  match.transition = result.from_keyword_provider() ?
       content::PAGE_TRANSITION_KEYWORD : content::PAGE_TRANSITION_GENERATED;
 
   return match;
 }
 
 void SearchProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
   provider_info->push_back(metrics::OmniboxEventProto_ProviderInfo());
   metrics::OmniboxEventProto_ProviderInfo& new_entry = provider_info->back();
   new_entry.set_provider(AsOmniboxEventProviderType());
   new_entry.set_provider_done(done_);
@@ skipping 63 matching lines @@
     } else {
       // The current top result is a navigational suggestion.
       if (nav_it->IsInlineable(input))
         break;
       nav_it = navigation_results->erase(nav_it);
     }
   }
 }
 
 // static
+void SearchProvider::RecalculateBolding(const string16& input_text,
+                                        const std::string languages,
+                                        Results* results) {
+  for (SuggestResults::iterator sug_it = results->suggest_results.begin();
+       sug_it != results->suggest_results.end(); ++sug_it) {
+    sug_it->CalculateContents(false, input_text);
+  }
+  for (NavigationResults::iterator nav_it = results->navigation_results.begin();
+       nav_it != results->navigation_results.end(); ++nav_it) {
+    nav_it->CalculateContents(false, input_text, languages);
+  }
+}
+
+// static
 int SearchProvider::CalculateRelevanceForKeywordVerbatim(
     AutocompleteInput::Type type,
     bool prefer_keyword) {
   // This function is responsible for scoring verbatim query matches
   // for non-extension keywords.  KeywordProvider::CalculateRelevance()
   // scores verbatim query matches for extension keywords, as well as
   // for keyword matches (i.e., suggestions of a keyword itself, not a
   // suggestion of a query on a keyword search engine).  These two
   // functions are currently in sync, but there's no reason we
   // couldn't decide in the future to score verbatim matches
@@ skipping 235 matching lines @@
        (!done_ &&
         input_.matches_requested() == AutocompleteInput::ALL_MATCHES)))
     return;
 
   // We can't keep running any previous query, so halt it.
   StopSuggest();
 
   // Remove existing results that cannot inline autocomplete the new input.
   RemoveAllStaleResults();
 
+  // Revise the bolding of all results that remain so they look good against
+  // the current input.
+  const std::string& languages =
+      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
+  RecalculateBolding(input_.text(), languages, &default_results_);
+  RecalculateBolding(keyword_input_.text(), languages, &keyword_results_);
+
   // We can't start a new query if we're only allowed synchronous results.
   if (input_.matches_requested() != AutocompleteInput::ALL_MATCHES)
     return;
 
   // To avoid flooding the suggest server, don't send a query until at
   // least 100 ms since the last query.
   base::TimeTicks next_suggest_time(time_suggest_request_sent_ +
       base::TimeDelta::FromMilliseconds(kMinimumTimeBetweenSuggestQueriesMs));
   base::TimeTicks now(base::TimeTicks::Now());
   if (now >= next_suggest_time) {
@@ skipping 201 matching lines @@
     field_trial_triggered_in_session_ |= triggered;
   }
 
   // Clear the previous results now that new results are available.
   results->suggest_results.clear();
   results->navigation_results.clear();
 
   string16 result, title;
   std::string type;
   int relevance = -1;
+  const std::string& languages =
+      profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
   for (size_t index = 0; results_list->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;
 
     // 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);
         results->navigation_results.push_back(NavigationResult(
-            *this, url, title, is_keyword, relevance, true));
+            *this, url, title, is_keyword, relevance, true, input_text,
+            languages));
       }
     } else {
       // TODO(kochi): Improve calculator result presentation.
       results->suggest_results.push_back(
-          SuggestResult(result, is_keyword, relevance, true));
+          SuggestResult(result, is_keyword, relevance, true, input_text));
     }
   }
 
   // Apply calculated relevance scores if a valid list was not provided.
   if (relevances == NULL) {
     ApplyCalculatedSuggestRelevance(&results->suggest_results);
     ApplyCalculatedNavigationRelevance(&results->navigation_results);
   }
   // Keep the result lists sorted.
   const CompareScoredResults comparator = CompareScoredResults();
@@ skipping 16 matching lines @@
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
 
   bool relevance_from_server;
   int verbatim_relevance = GetVerbatimRelevance(&relevance_from_server);
   int did_not_accept_default_suggestion =
       default_results_.suggest_results.empty() ?
       TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
       TemplateURLRef::NO_SUGGESTION_CHOSEN;
   if (verbatim_relevance > 0) {
-    AddMatchToMap(input_.text(), input_.text(), verbatim_relevance,
-                  relevance_from_server,
+    SuggestResult verbatim(input_.text(), false, verbatim_relevance,
+                           relevance_from_server, input_.text());
+    AddMatchToMap(verbatim, input_.text(),
                   AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-                  did_not_accept_default_suggestion, false, &map);
+                  did_not_accept_default_suggestion, &map);
   }
   if (!keyword_input_.text().empty()) {
     const TemplateURL* keyword_url = providers_.GetKeywordProviderURL();
     // We only create the verbatim search query match for a keyword
     // if it's not an extension keyword.  Extension keywords are handled
     // in KeywordProvider::Start().  (Extensions are complicated...)
     // Note: in this provider, SEARCH_OTHER_ENGINE must correspond
     // to the keyword verbatim search query.  Do not create other matches
     // of type SEARCH_OTHER_ENGINE.
     if (keyword_url && !keyword_url->IsExtensionKeyword()) {
       bool keyword_relevance_from_server;
       const int keyword_verbatim_relevance =
           GetKeywordVerbatimRelevance(&keyword_relevance_from_server);
       if (keyword_verbatim_relevance > 0) {
-        AddMatchToMap(keyword_input_.text(), keyword_input_.text(),
-                      keyword_verbatim_relevance, keyword_relevance_from_server,
+        SuggestResult keyword_verbatim(
+            keyword_input_.text(), true, keyword_verbatim_relevance,
+            keyword_relevance_from_server, keyword_input_.text());
+        AddMatchToMap(keyword_verbatim, keyword_input_.text(),
                       AutocompleteMatchType::SEARCH_OTHER_ENGINE,
-                      did_not_accept_keyword_suggestion, true, &map);
+                      did_not_accept_keyword_suggestion, &map);
       }
     }
   }
   AddHistoryResultsToMap(keyword_history_results_, true,
                          did_not_accept_keyword_suggestion, &map);
   AddHistoryResultsToMap(default_history_results_, false,
                          did_not_accept_default_suggestion, &map);
 
   AddSuggestResultsToMap(keyword_results_.suggest_results, &map);
   AddSuggestResultsToMap(default_results_.suggest_results, &map);
@@ skipping 202 matching lines @@
              AutocompleteResult::kLowestDefaultScore) ||
         !HasMultipleWords(scored_results.front().suggestion()))
       scored_results.clear();  // Didn't detect the case above, score normally.
   }
   if (scored_results.empty())
     scored_results = ScoreHistoryResults(results, prevent_inline_autocomplete,
                                          input_multiple_words, input_text,
                                          is_keyword);
   for (SuggestResults::const_iterator i(scored_results.begin());
        i != scored_results.end(); ++i) {
-    AddMatchToMap(i->suggestion(), input_text, i->relevance(), false,
+    AddMatchToMap(*i, input_text,
                   AutocompleteMatchType::SEARCH_HISTORY,
-                  did_not_accept_suggestion,
-                  is_keyword, map);
+                  did_not_accept_suggestion, map);
   }
 }
 
 SearchProvider::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
     bool input_multiple_words,
     const string16& input_text,
     bool is_keyword) {
   AutocompleteClassifier* classifier =
@@ skipping 26 matching lines @@
       AutocompleteMatch match;
       classifier->Classify(i->term, false, false, &match, NULL);
       prevent_inline_autocomplete =
           !AutocompleteMatch::IsSearchType(match.type);
     }
 
     int relevance = CalculateRelevanceForHistory(
         i->time, is_keyword, !prevent_inline_autocomplete,
         prevent_search_history_inlining);
     scored_results.push_back(
-        SuggestResult(i->term, is_keyword, relevance, false));
+        SuggestResult(i->term, is_keyword, relevance, false, input_text));
   }
 
   // History returns results sorted for us.  However, we may have docked some
   // results' scores, so things are no longer in order.  Do a stable sort to get
   // things back in order without otherwise disturbing results with equal
   // scores, then force the scores to be unique, so that the order in which
   // they're shown is deterministic.
   std::stable_sort(scored_results.begin(), scored_results.end(),
                    CompareScoredResults());
   int last_relevance = 0;
   for (SuggestResults::iterator i(scored_results.begin());
        i != scored_results.end(); ++i) {
     if ((i != scored_results.begin()) && (i->relevance() >= last_relevance))
       i->set_relevance(last_relevance - 1);
     last_relevance = i->relevance();
   }
 
   return scored_results;
 }
 
 void SearchProvider::AddSuggestResultsToMap(const SuggestResults& results,
                                             MatchMap* map) {
   for (size_t i = 0; i < results.size(); ++i) {
-    const bool is_keyword = results[i].from_keyword_provider();
-    const string16& input = is_keyword ? keyword_input_.text() : input_.text();
-    AddMatchToMap(results[i].suggestion(), input, results[i].relevance(),
-                  results[i].relevance_from_server(),
-                  AutocompleteMatchType::SEARCH_SUGGEST, i, is_keyword, map);
+    const string16& input = results[i].from_keyword_provider() ?
+        keyword_input_.text() : input_.text();
+    AddMatchToMap(results[i], input,
+                  AutocompleteMatchType::SEARCH_SUGGEST, i, map);
   }
 }
 
 int SearchProvider::GetVerbatimRelevance(bool* relevance_from_server) const {
   // Use the suggested verbatim relevance score if it is non-negative (valid),
   // if inline autocomplete isn't prevented (always show verbatim on backspace),
   // and if it won't suppress verbatim, leaving no default provider matches.
   // Otherwise, if the default provider returned no matches and was still able
   // to suppress verbatim, the user would have no search/nav matches and may be
   // left unable to search using their default provider from the omnibox.
@@ skipping 91 matching lines @@
   // Don't let scores go below 0.  Negative relevance scores are meaningful in
   // a different way.
   int base_score;
   if (is_primary_provider)
     base_score = (input_.type() == AutocompleteInput::URL) ? 750 : 1050;
   else
     base_score = 200;
   return std::max(0, base_score - score_discount);
 }
 
-void SearchProvider::AddMatchToMap(const string16& query_string,
+void SearchProvider::AddMatchToMap(const SuggestResult& result,
                                    const string16& input_text,
-                                   int relevance,
-                                   bool relevance_from_server,
                                    AutocompleteMatch::Type type,
                                    int accepted_suggestion,
-                                   bool is_keyword,
                                    MatchMap* map) {
   // On non-mobile, ask the instant controller for the appropriate start margin.
   // On mobile the start margin is unused, so leave the value as default there.
   int omnibox_start_margin = chrome::kDisableStartMargin;
 #if !defined(OS_ANDROID) && !defined(IOS)
   if (chrome::IsInstantExtendedAPIEnabled()) {
     Browser* browser =
         chrome::FindBrowserWithProfile(profile_, chrome::GetActiveDesktop());
     if (browser && browser->instant_controller() &&
         browser->instant_controller()->instant()) {
       omnibox_start_margin =
           browser->instant_controller()->instant()->omnibox_bounds().x();
     }
   }
 #endif  // !defined(OS_ANDROID) && !defined(IOS)
 
-  const TemplateURL* template_url = is_keyword ?
+  const TemplateURL* template_url = result.from_keyword_provider() ?
       providers_.GetKeywordProviderURL() : providers_.GetDefaultProviderURL();
-  AutocompleteMatch match = CreateSearchSuggestion(this, relevance, type,
-      template_url, query_string, input_text, input_, is_keyword,
-      accepted_suggestion, omnibox_start_margin,
-      !is_keyword || providers_.default_provider().empty());
+  AutocompleteMatch match = CreateSearchSuggestion(this, result,
+      type, template_url, input_text, input_, accepted_suggestion,
+      omnibox_start_margin,
+     !result.from_keyword_provider() || providers_.default_provider().empty());
   if (!match.destination_url.is_valid())
     return;
   match.RecordAdditionalInfo(kRelevanceFromServerKey,
-                             relevance_from_server ? kTrue : kFalse);
+                             result.relevance_from_server() ? kTrue : kFalse);
 
   // 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.
-  const std::pair<MatchMap::iterator, bool> i(
-      map->insert(std::make_pair(base::i18n::ToLower(query_string), match)));
+  const std::pair<MatchMap::iterator, bool> i(map->insert(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 SearchProvider::NavigationToMatch(
     const NavigationResult& navigation) {
   const string16& input = navigation.from_keyword_provider() ?
       keyword_input_.text() : input_.text();
   AutocompleteMatch match(this, navigation.relevance(), false,
                           AutocompleteMatchType::NAVSUGGEST);
   match.destination_url = navigation.url();
 
-  // First look for the user's input inside the fill_into_edit as it would be
-  // without trimming the scheme, so we can find matches at the beginning of the
-  // scheme.
-  const string16& untrimmed_fill_into_edit = navigation.formatted_url();
-  const URLPrefix* prefix =
-      URLPrefix::BestURLPrefix(untrimmed_fill_into_edit, input);
-  size_t match_start = (prefix == NULL) ?
-      untrimmed_fill_into_edit.find(input) : prefix->prefix.length();
-  size_t inline_autocomplete_offset = (prefix == NULL) ?
-      string16::npos : (match_start + input.length());
-  bool trim_http = !HasHTTPScheme(input) && (!prefix || (match_start != 0));
-
+  bool trim_http;
+  size_t match_start, inline_autocomplete_offset;
+  GetTrimHttpAndOffsets(navigation.formatted_url(), input, &trim_http,
+                        &match_start, &inline_autocomplete_offset);
   // Preserve the forced query '?' prefix in |match.fill_into_edit|.
   // Otherwise, user edits to a suggestion would show non-Search results.
   if (input_.type() == AutocompleteInput::FORCED_QUERY) {
     match.fill_into_edit = ASCIIToUTF16("?");
     if (inline_autocomplete_offset != string16::npos)
       ++inline_autocomplete_offset;
   }
 
   const std::string languages(
       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
   const net::FormatUrlTypes format_types =
       net::kFormatUrlOmitAll & ~(trim_http ? 0 : net::kFormatUrlOmitHTTP);
   match.fill_into_edit +=
       AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url(),
           net::FormatUrl(navigation.url(), languages, format_types,
                          net::UnescapeRule::SPACES, NULL, NULL,
                          &inline_autocomplete_offset));
   if (!input_.prevent_inline_autocomplete() &&
       (inline_autocomplete_offset != string16::npos)) {
     DCHECK(inline_autocomplete_offset <= match.fill_into_edit.length());
     match.allowed_to_be_default_match = true;
     match.inline_autocompletion =
         match.fill_into_edit.substr(inline_autocomplete_offset);
   }
 
-  match.contents = net::FormatUrl(navigation.url(), languages,
-      format_types, net::UnescapeRule::SPACES, NULL, NULL, &match_start);
-  // If the first match in the untrimmed string was inside a scheme that we
-  // trimmed, look for a subsequent match.
-  if (match_start == string16::npos)
-    match_start = match.contents.find(input);
-  // Safe if |match_start| is npos; also safe if the input is longer than the
-  // remaining contents after |match_start|.
-  AutocompleteMatch::ClassifyLocationInString(match_start, input.length(),
-      match.contents.length(), ACMatchClassification::URL,
-      &match.contents_class);
-
+  match.contents = navigation.contents();
+  match.contents_class = navigation.contents_class();
   match.description = navigation.description();
   AutocompleteMatch::ClassifyMatchInString(input, match.description,
       ACMatchClassification::NONE, &match.description_class);
 
   match.RecordAdditionalInfo(
       kRelevanceFromServerKey,
       navigation.relevance_from_server() ? kTrue : kFalse);
 
   return match;
 }
@@ skipping 37 matching lines @@
     it->set_relevance(max_query_relevance);
     it->set_relevance_from_server(relevance_from_server);
   }
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when the timer isn't running, there are no suggest queries
   // pending, and we're not waiting on Instant.
   done_ = !timer_.IsRunning() && (suggest_results_pending_ == 0);
 }