Changes SearchProvider to set the description of the first consecutive

chrome/browser/autocomplete/search_provider.cc

 // Copyright (c) 2011 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 73 matching lines @@
 
   string16 adjusted_input_text(input_text);
   AutocompleteInput::RemoveForcedQueryStringIfNecessary(input_.type(),
                                                         &adjusted_input_text);
 
   const string16 text = adjusted_input_text + suggest_text;
   // Remove any matches that are identical to |text|. We don't use the
   // destination_url for comparison as it varies depending upon the index passed
   // to TemplateURL::ReplaceSearchTerms.
   for (ACMatches::iterator i = matches_.begin(); i != matches_.end();) {
-    // Reset the description/description_class of all searches. We'll set the
-    // description of the new first match in the call to
-    // UpdateFirstSearchMatchDescription() below.
-    if ((i->type == AutocompleteMatch::SEARCH_HISTORY) ||
-        (i->type == AutocompleteMatch::SEARCH_SUGGEST) ||
-        (i->type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED)) {
-      i->description.clear();
-      i->description_class.clear();
-    }
-
     if (((i->type == AutocompleteMatch::SEARCH_HISTORY) ||
          (i->type == AutocompleteMatch::SEARCH_SUGGEST)) &&
         (i->fill_into_edit == text)) {
       i = matches_.erase(i);
     } else {
       ++i;
     }
   }
 
   // Add the new suggest result. We give it a rank higher than
   // SEARCH_WHAT_YOU_TYPED so that it gets autocompleted.
   int did_not_accept_default_suggestion = default_suggest_results_.empty() ?
         TemplateURLRef::NO_SUGGESTIONS_AVAILABLE :
         TemplateURLRef::NO_SUGGESTION_CHOSEN;
   MatchMap match_map;
   AddMatchToMap(text, adjusted_input_text,
                 CalculateRelevanceForWhatYouTyped() + 1,
                 AutocompleteMatch::SEARCH_SUGGEST,
                 did_not_accept_default_suggestion, false,
                 input_.prevent_inline_autocomplete(), &match_map);
   DCHECK_EQ(1u, match_map.size());
   matches_.push_back(match_map.begin()->second);
-  // Sort the results so that UpdateFirstSearchDescription does the right thing.
-  std::sort(matches_.begin(), matches_.end(), &AutocompleteMatch::MoreRelevant);
-
-  UpdateFirstSearchMatchDescription();
 
   listener_->OnProviderUpdate(true);
 }
 
 void SearchProvider::Start(const AutocompleteInput& input,
                            bool minimal_changes) {
   matches_.clear();
 
   instant_finalized_ =
       (input.matches_requested() != AutocompleteInput::ALL_MATCHES);
@@ skipping 40 matching lines @@
 
   if (input.text().empty()) {
     // User typed "?" alone.  Give them a placeholder result indicating what
     // this syntax does.
     if (default_provider) {
       AutocompleteMatch match;
       match.provider = this;
       match.contents.assign(l10n_util::GetStringUTF16(IDS_EMPTY_KEYWORD_VALUE));
       match.contents_class.push_back(
           ACMatchClassification(0, ACMatchClassification::NONE));
+      match.template_url = &providers_.default_provider();
       matches_.push_back(match);
-      UpdateFirstSearchMatchDescription();
     }
     Stop();
     return;
   }
 
   input_ = input;
 
   DoHistoryQuery(minimal_changes);
   StartOrStopSuggestQuery(minimal_changes);
   ConvertResultsToAutocompleteMatches();
@@ skipping 20 matching lines @@
   // providers.
   DCHECK_GT(suggest_results_pending_, 0);
 }
 
 void SearchProvider::Stop() {
   StopSuggest();
   done_ = true;
   default_provider_suggest_text_.clear();
 }
 
+void SearchProvider::PostProcessResult(AutocompleteResult* result) {
+  // For each group of contiguous matches from the same TemplateURL, show the
+  // provider name as a description on the first match in the group.
+  const TemplateURL* last_template_url = NULL;
+  for (AutocompleteResult::iterator i = result->begin(); i != result->end();
+       ++i) {
+    if (i->provider == this &&
+        (i->type == AutocompleteMatch::SEARCH_WHAT_YOU_TYPED ||
+         i->type == AutocompleteMatch::SEARCH_HISTORY ||
+         i->type == AutocompleteMatch::SEARCH_SUGGEST)) {
+      i->description.clear();
+      i->description_class.clear();
+      DCHECK(i->template_url);  // We should always set a template_url
+      if (last_template_url != i->template_url) {
+        i->description = l10n_util::GetStringFUTF16(
+            IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION,
+            i->template_url->AdjustedShortNameForLocaleDirection());
+        i->description_class.push_back(
+            ACMatchClassification(0, ACMatchClassification::DIM));
+      }
+      last_template_url = i->template_url;
+    } else {
+      last_template_url = NULL;
+    }
+  }
+}
+
 void SearchProvider::OnURLFetchComplete(const URLFetcher* source,
                                         const GURL& url,
                                         const net::URLRequestStatus& status,
                                         int response_code,
                                         const net::ResponseCookies& cookie,
                                         const std::string& data) {
   DCHECK(!done_);
   suggest_results_pending_--;
   DCHECK_GE(suggest_results_pending_, 0);  // Should never go negative.
   const net::HttpResponseHeaders* const response_headers =
@@ skipping 328 matching lines @@
   AddNavigationResultsToMatches(keyword_navigation_results_, true);
   AddNavigationResultsToMatches(default_navigation_results_, false);
 
   const size_t max_total_matches = kMaxMatches + 1;  // 1 for "what you typed"
   std::partial_sort(matches_.begin(),
       matches_.begin() + std::min(max_total_matches, matches_.size()),
       matches_.end(), &AutocompleteMatch::MoreRelevant);
   if (matches_.size() > max_total_matches)
     matches_.erase(matches_.begin() + max_total_matches, matches_.end());
 
-  UpdateFirstSearchMatchDescription();
-
   UpdateStarredStateOfMatches();
 
   UpdateDone();
 }
 
 void SearchProvider::AddNavigationResultsToMatches(
     const NavigationResults& navigation_results,
     bool is_keyword) {
   if (!navigation_results.empty()) {
     // TODO(kochi): http://b/1170574  We add only one results for navigational
@@ skipping 159 matching lines @@
                                    int relevance,
                                    AutocompleteMatch::Type type,
                                    int accepted_suggestion,
                                    bool is_keyword,
                                    bool prevent_inline_autocomplete,
                                    MatchMap* map) {
   AutocompleteMatch match(this, relevance, false, type);
   std::vector<size_t> content_param_offsets;
   const TemplateURL& provider = is_keyword ? providers_.keyword_provider() :
                                              providers_.default_provider();
+  match.template_url = &provider;
   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.
@@ skipping 31 matching lines @@
   // values preserve that property.  Otherwise, if the user starts editing a
   // suggestion, non-Search results will suddenly appear.
   size_t search_start = 0;
   if (input_.type() == AutocompleteInput::FORCED_QUERY) {
     match.fill_into_edit.assign(ASCIIToUTF16("?"));
     ++search_start;
   }
   if (is_keyword) {
     match.fill_into_edit.append(
         providers_.keyword_provider().keyword() + char16(' '));
-    match.template_url = &providers_.keyword_provider();
   }
   match.fill_into_edit.append(query_string);
   // Not all suggestions start with the original input.
   if (!prevent_inline_autocomplete &&
       !match.fill_into_edit.compare(search_start, input_text.length(),
                                    input_text))
     match.inline_autocomplete_offset = search_start + input_text.length();
 
   const TemplateURLRef* const search_url = provider.url();
   DCHECK(search_url->SupportsReplacement());
@@ skipping 29 matching lines @@
     const NavigationResult& navigation,
     int relevance,
     bool is_keyword) {
   const string16& input_text =
       is_keyword ? keyword_input_text_ : input_.text();
   AutocompleteMatch match(this, relevance, false,
                           AutocompleteMatch::NAVSUGGEST);
   match.destination_url = navigation.url;
   match.contents =
       StringForURLDisplay(navigation.url, true, !HasHTTPScheme(input_text));
+  match.template_url = is_keyword ? &providers_.keyword_provider() :
+                                    &providers_.default_provider();
   AutocompleteMatch::ClassifyMatchInString(input_text, match.contents,
                                            ACMatchClassification::URL,
                                            &match.contents_class);
 
   match.description = navigation.site_name;
   AutocompleteMatch::ClassifyMatchInString(input_text, navigation.site_name,
                                            ACMatchClassification::NONE,
                                            &match.description_class);
 
   // 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("?"));
   match.fill_into_edit.append(
       AutocompleteInput::FormattedStringWithEquivalentMeaning(navigation.url,
                                                               match.contents));
   // TODO(pkasting): http://b/1112879 These should perhaps be
   // inline-autocompletable?
 
   return match;
 }
 
 void SearchProvider::UpdateDone() {
   // We're done when there are no more suggest queries pending (this is set to 1
   // when the timer is started) and we're not waiting on instant.
   done_ = ((suggest_results_pending_ == 0) &&
            (instant_finalized_ || !InstantController::IsEnabled(profile_)));
 }
-
-void SearchProvider::UpdateFirstSearchMatchDescription() {
-  if (!providers_.valid_default_provider() || matches_.empty())
-    return;
-
-  for (ACMatches::iterator i = matches_.begin(); i != matches_.end(); ++i) {
-    AutocompleteMatch& match = *i;
-    switch (match.type) {
-      case AutocompleteMatch::SEARCH_WHAT_YOU_TYPED:
-      case AutocompleteMatch::SEARCH_HISTORY:
-      case AutocompleteMatch::SEARCH_SUGGEST:
-        match.description.assign(l10n_util::GetStringFUTF16(
-            IDS_AUTOCOMPLETE_SEARCH_DESCRIPTION,
-            providers_.default_provider().
-                AdjustedShortNameForLocaleDirection()));
-        match.description_class.push_back(
-            ACMatchClassification(0, ACMatchClassification::DIM));
-        // Only the first search match gets a description.
-        return;
-
-      default:
-        break;
-    }
-  }
-}