Omnibox: Make the Controller Reorder Matches for Inlining

chrome/browser/autocomplete/keyword_provider.cc

 // Copyright (c) 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/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/strings/string16.h"
@@ skipping 197 matching lines @@
       return string16();
   }
 
   return keyword;
 }
 
 AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
     const string16& text,
     const string16& keyword,
     const AutocompleteInput& input) {
+  // This enclosing function is only called by omnibox_controller.cc to create
+  // a what-you-typed match on the keyword input.  It's okay to allow this
+  // match to be the default match.

[H Fung, 2013/08/08 20:10:36]

I'm not sure if it's worth changing the function name because of this (to
something like CreateWhatYouTypedMatch)

[Mark P, 2013/08/08 22:06:10]

A reasonable idea.  I think it makes things clearer.  Done.

[Peter Kasting, 2013/08/09 21:59:34]

Does not seem changed?

[Mark P, 2013/08/09 22:24:11]

Already did; you didn't review the most recent patch.

   return CreateAutocompleteMatch(
       GetTemplateURLService()->GetTemplateURLForKeyword(keyword), input,
-      keyword.length(), SplitReplacementStringFromInput(text, true), 0);
+      keyword.length(), SplitReplacementStringFromInput(text, true), true, 0);
 }
 
 void KeywordProvider::Start(const AutocompleteInput& input,
                             bool minimal_changes) {
   // This object ensures we end keyword mode if we exit the function without
   // toggling keyword mode to on.
   ScopedEndExtensionKeywordMode keyword_mode_toggle(this);
 
   matches_.clear();
 
@@ skipping 80 matching lines @@
     // Only create an exact match if |remaining_input| is empty or if
     // this is an extension keyword.  If |remaining_input| is a
     // non-empty non-extension keyword (i.e., a regular keyword that
     // supports replacement and that has extra text following it),
     // then SearchProvider creates the exact (a.k.a. verbatim) match.
     if (!remaining_input.empty() && !is_extension_keyword)
       return;
 
     // TODO(pkasting): We should probably check that if the user explicitly
     // typed a scheme, that scheme matches the one in |template_url|.
+
+    // When creating an exact match (either for the keyword itself, no
+    // remaining query or an extension keyword, possibly with remaining
+    // input), allow the match to be the default match.
     matches_.push_back(CreateAutocompleteMatch(
-        template_url, input, keyword.length(), remaining_input, -1));
+        template_url, input, keyword.length(), remaining_input, true, -1));
 
     if (profile_ && is_extension_keyword) {
       if (input.matches_requested() == AutocompleteInput::ALL_MATCHES) {
         if (template_url->GetExtensionId() != current_keyword_extension_id_)
           MaybeEndExtensionKeywordMode();
         if (current_keyword_extension_id_.empty())
           EnterExtensionKeywordMode(template_url->GetExtensionId());
         keyword_mode_toggle.StayInKeywordMode();
       }
 
@@ skipping 25 matching lines @@
         if (have_listeners)
           done_ = false;
       }
     }
   } else {
     if (matches.size() > kMaxMatches)
       matches.erase(matches.begin() + kMaxMatches, matches.end());
     for (TemplateURLService::TemplateURLVector::const_iterator i(
          matches.begin()); i != matches.end(); ++i) {
       matches_.push_back(CreateAutocompleteMatch(
-          *i, input, keyword.length(), remaining_input, -1));
+          *i, input, keyword.length(), remaining_input, false, -1));
     }
   }
 }
 
 void KeywordProvider::Stop(bool clear_cached_results) {
   done_ = true;
   MaybeEndExtensionKeywordMode();
 }
 
 KeywordProvider::~KeywordProvider() {}
@@ skipping 34 matching lines @@
     return 1500;
   return (allow_exact_keyword_match && (type == AutocompleteInput::QUERY)) ?
       1450 : 1100;
 }
 
 AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
     const TemplateURL* template_url,
     const AutocompleteInput& input,
     size_t prefix_length,
     const string16& remaining_input,
+    bool allowed_to_be_default_match,
     int relevance) {
   DCHECK(template_url);
   const bool supports_replacement =
       template_url->url_ref().SupportsReplacement();
 
   // Create an edit entry of "[keyword] [remaining input]".  This is helpful
   // even when [remaining input] is empty, as the user can select the popup
   // choice and immediately begin typing in query input.
   const string16& keyword = template_url->keyword();
   const bool keyword_complete = (prefix_length == keyword.length());
   if (relevance < 0) {
     relevance =
         CalculateRelevance(input.type(), keyword_complete,
                            // When the user wants keyword matches to take
                            // preference, score them highly regardless of
                            // whether the input provides query text.
                            supports_replacement, input.prefer_keyword(),
                            input.allow_exact_keyword_match());
   }
   AutocompleteMatch match(this, relevance, false,
       supports_replacement ? AutocompleteMatchType::SEARCH_OTHER_ENGINE :
                              AutocompleteMatchType::HISTORY_KEYWORD);
+  match.allowed_to_be_default_match = allowed_to_be_default_match;
   match.fill_into_edit = keyword;
   if (!remaining_input.empty() || !keyword_complete || supports_replacement)
     match.fill_into_edit.push_back(L' ');
   match.fill_into_edit.append(remaining_input);
   // If we wanted to set |result.inline_autocompletion| correctly, we'd need
   // CleanUserInputKeyword() to return the amount of adjustment it's made to
   // the user's input.  Because right now inexact keyword matches can't score
   // more highly than a "what you typed" match from one of the other providers,
   // we just don't bother to do this, and leave inline autocompletion off.
 
@@ skipping 105 matching lines @@
           model->GetTemplateURLForKeyword(keyword);
 
       // TODO(mpcomplete): consider clamping the number of suggestions to
       // AutocompleteProvider::kMaxMatches.
       for (size_t i = 0; i < suggestions.suggest_results.size(); ++i) {
         const omnibox_api::SuggestResult& suggestion =
             *suggestions.suggest_results[i];
         // We want to order these suggestions in descending order, so start with
         // the relevance of the first result (added synchronously in Start()),
         // and subtract 1 for each subsequent suggestion from the extension.
-        // We know that |complete| is true, because we wouldn't get results from
-        // the extension unless the full keyword had been typed.
+        // We recompute the first match's relevance; we know that |complete|
+        // is true, because we wouldn't get results from the extension unless
+        // the full keyword had been typed.
         int first_relevance = CalculateRelevance(input.type(), true, true,
             input.prefer_keyword(), input.allow_exact_keyword_match());
+        // Because these matches are async, we should never let them become the
+        // default match, lest we introduce race conditions in the omnibox user
+        // interaction.
         extension_suggest_matches_.push_back(CreateAutocompleteMatch(
             template_url, input, keyword.length(),
-            UTF8ToUTF16(suggestion.content), first_relevance - (i + 1)));
+            UTF8ToUTF16(suggestion.content), false, first_relevance - (i + 1)));
 
         AutocompleteMatch* match = &extension_suggest_matches_.back();
         match->contents.assign(UTF8ToUTF16(suggestion.description));
         match->contents_class =
             extensions::StyleTypesToACMatchClassifications(suggestion);
         match->description.clear();
         match->description_class.clear();
       }
 
       done_ = true;
@@ skipping 29 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     extensions::ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }