Omnibox: Don't Autocomplete Previously-Issued Search Queries

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/base64.h"
@@ skipping 876 matching lines @@
 
 SearchProvider::SuggestResults SearchProvider::ScoreHistoryResults(
     const HistoryResults& results,
     bool base_prevent_inline_autocomplete,
     bool input_multiple_words,
     const base::string16& input_text,
     bool is_keyword) {
   AutocompleteClassifier* classifier =
       AutocompleteClassifierFactory::GetForProfile(profile_);
   SuggestResults scored_results;
+  // True if the user has asked this exact query previously.
+  bool found_what_you_typed_match = false;
   const bool prevent_search_history_inlining =
       OmniboxFieldTrial::SearchHistoryPreventInlining(
           input_.current_page_classification());
   const base::string16& trimmed_input =
       base::CollapseWhitespace(input_text, false);
   for (HistoryResults::const_iterator i(results.begin()); i != results.end();
        ++i) {
     const base::string16& trimmed_suggestion =
         base::CollapseWhitespace(i->term, false);
 
@@ skipping 21 matching lines @@
       AutocompleteMatch match;
       classifier->Classify(trimmed_suggestion, false, false,
                            input_.current_page_classification(), &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(
+    // Add the match to |scored_results| by putting the what-you-typed match
+    // on the front and appending all other matches.  We want the what-you-
+    // typed match to always be first.
+    SuggestResults::iterator insertion_position = scored_results.end();
+    if (trimmed_suggestion == trimmed_input) {
+      found_what_you_typed_match = true;
+      insertion_position = scored_results.begin();
+    }
+    scored_results.insert(insertion_position, SuggestResult(
         trimmed_suggestion, AutocompleteMatchType::SEARCH_HISTORY,
         trimmed_suggestion, base::string16(), base::string16(),
         base::string16(), base::string16(), std::string(), std::string(),
         is_keyword, relevance, false, false, trimmed_input));
   }
 
   // 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
+  // results' scores, so things are no longer in order.  While keeping the
+  // what-you-typed match at the front (if it exists), 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(),
+  std::stable_sort(scored_results.begin() +
+                       (found_what_you_typed_match ? 1 : 0),
+                   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;
@@ skipping 207 matching lines @@
     // Make the base64 encoded value URL and filename safe(see RFC 3548).
     std::replace(current_token_.begin(), current_token_.end(), '+', '-');
     std::replace(current_token_.begin(), current_token_.end(), '/', '_');
   }
 
   // Extend expiration time another 60 seconds.
   token_expiration_time_ = current_time + base::TimeDelta::FromSeconds(60);
 
   return current_token_;
 }