Omnibox: Prevent Asynchronous Suggestions from Changing Default Match

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 242 matching lines @@
       match.keyword = providers_.default_provider();
       match.allowed_to_be_default_match = true;
       matches_.push_back(match);
     }
     Stop(true);
     return;
   }
 
   input_ = input;
 
+  // If Start() is called without minimal_changes, it likely means the user
+  // has pressed a key.  This is a good opportunity to change the inline
+  // autocompletion (if any).  Restore the results to the original reply
+  // received from the server, thus clobbering any modification (if any) made
+  // to the results to demote an brand new async inline autocompletion.
+  if (!minimal_changes) {
+    default_results_ = orig_default_results_;
+    keyword_results_ = orig_keyword_results_;
+  }
+
   DoHistoryQuery(minimal_changes);
   DoAnswersQuery(input);
   StartOrStopSuggestQuery(minimal_changes);
   UpdateMatches();
 }
 
 void SearchProvider::SortResults(bool is_keyword,
                                  SearchSuggestionParser::Results* results) {
   // Ignore suggested scores for non-keyword matches in keyword mode; if the
   // server is allowed to score these, it could interfere with the user's
@@ skipping 24 matching lines @@
   return is_keyword ? providers_.GetKeywordProviderURL()
                     : providers_.GetDefaultProviderURL();
 }
 
 const AutocompleteInput SearchProvider::GetInput(bool is_keyword) const {
   return is_keyword ? keyword_input_ : input_;
 }
 
 SearchSuggestionParser::Results* SearchProvider::GetResultsToFill(
     bool is_keyword) {
-  return is_keyword ? &keyword_results_ : &default_results_;
+  return is_keyword ? &orig_keyword_results_ : &orig_default_results_;
+}
+
+void SearchProvider::HandleReceivedResults(bool is_keyword) {
+  // The general strategy of this function:
+  // 1.  Get the needed information from the previously-displayed results.
+  // 2.  Copy the newly-received results over the previously-displayed ones.
+  // 3.  Modify these results as necessary.
+
+  // 1.  Extract needed information.
+  // Determine the previous inline autocompletion, if any.
+  // We store the inlined suggestion (if any) in one of the two following
+  // variables, leaving them blank if there is no inline suggestion or the
+  // inlined suggestion is not of that type.
+  base::string16 inlined_query_suggestion_match_contents;
+  GURL inlined_navsuggestion;
+  ACMatches::const_iterator first_match = FindTopMatch();
+  if ((first_match != matches_.end()) &&
+      !first_match->inline_autocompletion.empty()) {
+    // Identify if this match came from a query suggestion or a navsuggestion.
+    // In either case, extracts the identifying feature of the suggestion
+    // (query string or navigation url).
+    if (AutocompleteMatch::IsSearchType(first_match->type)) {
+      inlined_query_suggestion_match_contents = first_match->contents;
+    } else {
+      inlined_navsuggestion = first_match->destination_url;
+    }
+  }
+
+  // 2.  Clobber the previous results.
+  SearchSuggestionParser::Results* results_from_server =
+      is_keyword ? &orig_keyword_results_ : &orig_default_results_;
+  SearchSuggestionParser::Results* results =
+      is_keyword ? &keyword_results_ : &default_results_;
+  (*results) = (*results_from_server);
+
+  // 3.  Modify the results.
+  // Mark all results aside from the previous inline autocompletion as not
+  // allowed to be the default match.
+  for (SearchSuggestionParser::SuggestResults::iterator sug_it =
+           results->suggest_results.begin();
+       sug_it != results->suggest_results.end(); ++sug_it) {
+    if (sug_it->match_contents() !=
+        inlined_query_suggestion_match_contents) {
+      sug_it->set_never_allowed_to_be_default_match(true);
+    }
+  }
+  for (SearchSuggestionParser::NavigationResults::iterator nav_it =
+           results->navigation_results.begin();
+       nav_it != results->navigation_results.end(); ++nav_it) {
+    if (nav_it->url() != inlined_navsuggestion) {
+      nav_it->set_never_allowed_to_be_default_match(true);
+    }
+  }
 }
 
 bool SearchProvider::ShouldAppendExtraParams(
     const SearchSuggestionParser::SuggestResult& result) const {
   return !result.from_keyword_provider() ||
       providers_.default_provider().empty();
 }
 
 void SearchProvider::StopSuggest() {
   // Increment the appropriate field in the histogram by the number of
   // pending requests that were invalidated.
   for (int i = 0; i < suggest_results_pending_; ++i)
     LogOmniboxSuggestRequest(REQUEST_INVALIDATED);
   suggest_results_pending_ = 0;
   timer_.Stop();
   // Stop any in-progress URL fetches.
   keyword_fetcher_.reset();
   default_fetcher_.reset();
 }
 
 void SearchProvider::ClearAllResults() {
   keyword_results_.Clear();
   default_results_.Clear();
+  orig_keyword_results_.Clear();
+  orig_default_results_.Clear();
 }
 
 int SearchProvider::GetDefaultResultRelevance() const {
   return -1;
 }
 
 void SearchProvider::RecordDeletionResult(bool success) {
   if (success) {
     content::RecordAction(
         base::UserMetricsAction("Omnibox.ServerSuggestDelete.Success"));
@@ skipping 276 matching lines @@
 }
 
 void SearchProvider::ApplyCalculatedSuggestRelevance(
     SearchSuggestionParser::SuggestResults* list) {
   for (size_t i = 0; i < list->size(); ++i) {
     SearchSuggestionParser::SuggestResult& result = (*list)[i];
     result.set_relevance(
         result.CalculateRelevance(input_, providers_.has_keyword_provider()) +
         (list->size() - i - 1));
     result.set_relevance_from_server(false);
+    result.set_never_allowed_to_be_default_match(false);
   }
 }
 
 void SearchProvider::ApplyCalculatedNavigationRelevance(
     SearchSuggestionParser::NavigationResults* list) {
   for (size_t i = 0; i < list->size(); ++i) {
     SearchSuggestionParser::NavigationResult& result = (*list)[i];
     result.set_relevance(
         result.CalculateRelevance(input_, providers_.has_keyword_provider()) +
         (list->size() - i - 1));
     result.set_relevance_from_server(false);
+    result.set_never_allowed_to_be_default_match(false);
   }
 }
 
 net::URLFetcher* SearchProvider::CreateSuggestFetcher(
     int id,
     const TemplateURL* template_url,
     const AutocompleteInput& input) {
   if (!template_url || template_url->suggestions_url().empty())
     return NULL;
 
@@ skipping 519 matching lines @@
         match.fill_into_edit.substr(inline_autocomplete_offset);
   }
   // An inlineable navsuggestion can only be the default match when there
   // is no keyword provider active, lest it appear first and break the user
   // out of keyword mode.  It can also only be default if either the inline
   // autocompletion is empty or we're not preventing inline autocompletion.
   // Finally, if we have an inlineable navsuggestion with an inline completion
   // that we're not preventing, make sure we didn't trim any whitespace.
   // We don't want to claim http://foo.com/bar is inlineable against the
   // input "foo.com/b ".
-  match.allowed_to_be_default_match = (prefix != NULL) &&
+  match.allowed_to_be_default_match =
+      !navigation.never_allowed_to_be_default_match() &&
+      (prefix != NULL) &&
       (providers_.GetKeywordProviderURL() == NULL) &&
       (match.inline_autocompletion.empty() ||
       (!input_.prevent_inline_autocomplete() && !trimmed_whitespace));
   match.EnsureUWYTIsAllowedToBeDefault(
       input_.canonicalized_url(), providers_.template_url_service());
 
   match.contents = navigation.match_contents();
   match.contents_class = navigation.match_contents_class();
   match.description = navigation.description();
   AutocompleteMatch::ClassifyMatchInString(input, match.description,
@@ skipping 53 matching lines @@
   last_answer_seen_.query_type = match->answer_type;
 }
 
 void SearchProvider::DoAnswersQuery(const AutocompleteInput& input) {
   // If the query text starts with trimmed input, this is valid prefetch data.
   prefetch_data_ = StartsWith(last_answer_seen_.full_query_text,
                               base::CollapseWhitespace(input.text(), false),
                               false) ?
       last_answer_seen_ : AnswersQueryData();
 }