Omnibox: Prevent Asynchronous Suggestions from Changing Default Match

chrome/browser/autocomplete/base_search_provider.cc

 // Copyright 2014 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/base_search_provider.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
@@ skipping 228 matching lines @@
     match.RecordAdditionalInfo(
         kACMatchPropertyContentsStartIndex,
         static_cast<int>(
             suggestion.suggestion().length() - match.contents.length()));
   }
 
   if (!suggestion.annotation().empty())
     match.description = suggestion.annotation();
 
   // suggestion.match_contents() should have already been collapsed.
   match.allowed_to_be_default_match =

[msw, 2014/08/14 02:57:22]

Should this also consider never_allowed_to_be_default_match()?

[Mark P, 2014/08/15 00:05:56]

No.  Something equivalent to verbatim is always allowed to be the default match.
 It shouldn't depend on whether it was received since the last keystroke or not
(that doesn't even make sense for verbatim).

       (base::CollapseWhitespace(input.text(), false) ==
        suggestion.match_contents());
 
   // 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() == metrics::OmniboxInputType::FORCED_QUERY)
     match.fill_into_edit.assign(base::ASCIIToUTF16("?"));
   if (suggestion.from_keyword_provider())
     match.fill_into_edit.append(match.keyword + base::char16(' '));
-  if (!input.prevent_inline_autocomplete() &&
+  if (!suggestion.never_allowed_to_be_default_match() &&
+      !input.prevent_inline_autocomplete() &&
       StartsWith(suggestion.suggestion(), input.text(), false)) {
     match.inline_autocompletion =
         suggestion.suggestion().substr(input.text().length());
     match.allowed_to_be_default_match = true;
   }
   match.fill_into_edit.append(suggestion.suggestion());
 
   const TemplateURLRef& search_url = template_url->url_ref();
   DCHECK(search_url.SupportsReplacement(search_terms_data));
   match.search_terms_args.reset(
@@ skipping 118 matching lines @@
   bool results_updated = false;
   if (request_succeeded) {
     std::string json_data = SearchSuggestionParser::ExtractJsonData(source);
     scoped_ptr<base::Value> data(
         SearchSuggestionParser::DeserializeJsonData(json_data));
     if (data && StoreSuggestionResponse(json_data, *data.get()))
       return;
 
     results_updated = data.get() && ParseSuggestResults(
         *data.get(), is_keyword, GetResultsToFill(is_keyword));
+    if (results_updated)
+      HandleReceivedResults(is_keyword);

[msw, 2014/08/14 02:57:22]

Is HandleReceivedResults really needed if we call UpdateMatches()?

[Mark P, 2014/08/15 00:05:56]

Huh.  I guess not.

   }
 
   UpdateMatches();
   if (done_ || results_updated)
     listener_->OnProviderUpdate(results_updated);
 }
 
 void BaseSearchProvider::AddMatchToMap(
     const SearchSuggestionParser::SuggestResult& result,
     const std::string& metadata,
@@ skipping 100 matching lines @@
 void BaseSearchProvider::SortResults(bool is_keyword,
                                      SearchSuggestionParser::Results* results) {
 }
 
 bool BaseSearchProvider::StoreSuggestionResponse(
     const std::string& json_data,
     const base::Value& parsed_data) {
   return false;
 }
 
+void BaseSearchProvider::HandleReceivedResults(bool is_keyword) {
+}
+
 void BaseSearchProvider::ModifyProviderInfo(
     metrics::OmniboxEventProto_ProviderInfo* provider_info) const {
 }
 
 void BaseSearchProvider::DeleteMatchFromMatches(
     const AutocompleteMatch& match) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i) {
     // Find the desired match to delete by checking the type and contents.
     // We can't check the destination URL, because the autocomplete controller
     // may have reformulated that. Not that while checking for matching
     // contents works for personalized suggestions, if more match types gain
     // deletion support, this algorithm may need to be re-examined.
     if (i->contents == match.contents && i->type == match.type) {
       matches_.erase(i);
       break;
     }
   }
 }
 
 void BaseSearchProvider::OnDeletionComplete(
     bool success, SuggestionDeletionHandler* handler) {
   RecordDeletionResult(success);
   SuggestionDeletionHandlers::iterator it = std::find(
       deletion_handlers_.begin(), deletion_handlers_.end(), handler);
   DCHECK(it != deletion_handlers_.end());
   deletion_handlers_.erase(it);
 }