Always allow exact match non-substituting keywords.

chrome/browser/autocomplete/keyword_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/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/string16.h"
@@ skipping 347 matching lines @@
     } else {
       // See comments on an identical NOTREACHED() in search_provider.cc.
       NOTREACHED();
     }
   }
 }
 
 // static
 int KeywordProvider::CalculateRelevance(AutocompleteInput::Type type,
                                         bool complete,
-                                        bool no_query_text_needed,
+                                        bool prefer_keyword,
+                                        bool supports_replacement,
                                         bool allow_exact_keyword_match) {
   if (!complete)
     return (type == AutocompleteInput::URL) ? 700 : 450;
-  if (!allow_exact_keyword_match)
+  if (!allow_exact_keyword_match && supports_replacement)

[Peter Kasting, 2011/01/25 23:20:44]

Nit: This is minor, but I wonder if it might not be clearer to do:

  if (!supports_replacement || (allow_exact_keyword_match && prefer_keyword))
    return 1500;
  return (allow_exact_keyword_match && (type == Autocomplete::QUERY)) ?
      1450 : 1100;

[James Su, 2011/01/26 00:53:31]

Done.

     return 1100;
-  if (no_query_text_needed)
+  if (prefer_keyword || !supports_replacement)
     return 1500;
   return (type == AutocompleteInput::QUERY) ? 1450 : 1100;
 }
 
 AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
     TemplateURLModel* model,
     const string16& keyword,
     const AutocompleteInput& input,
     size_t prefix_length,
     const string16& remaining_input,
     int relevance) {
   DCHECK(model);
   // Get keyword data from data store.
   const TemplateURL* element(
       model->GetTemplateURLForKeyword(keyword));
   DCHECK(element && element->url());
   const bool supports_replacement = element->url()->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 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.
-                           input.prefer_keyword() || !supports_replacement,
+                           input.prefer_keyword(), supports_replacement,
                            input.allow_exact_keyword_match());
   }
   AutocompleteMatch result(this, relevance, false,
       supports_replacement ? AutocompleteMatch::SEARCH_OTHER_ENGINE :
                              AutocompleteMatch::HISTORY_KEYWORD);
   result.fill_into_edit.assign(keyword);
   if (!remaining_input.empty() || !keyword_complete || supports_replacement)
     result.fill_into_edit.push_back(L' ');
   result.fill_into_edit.append(remaining_input);
   // If we wanted to set |result.inline_autocomplete_offset| correctly, we'd
@@ skipping 74 matching lines @@
       // AutocompleteProvider::kMaxMatches.
       for (size_t i = 0; i < suggestions.suggestions.size(); ++i) {
         const ExtensionOmniboxSuggestion& suggestion =
             suggestions.suggestions[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.
         int first_relevance = CalculateRelevance(input.type(), true,
-            input.prefer_keyword(), input.allow_exact_keyword_match());
+            input.prefer_keyword(), true, input.allow_exact_keyword_match());
         extension_suggest_matches_.push_back(CreateAutocompleteMatch(
             model, keyword, input, keyword.length(),
             suggestion.content, first_relevance - (i + 1)));
 
         AutocompleteMatch* match = &extension_suggest_matches_.back();
         match->contents.assign(suggestion.description);
         match->contents_class = suggestion.description_styles;
         match->description.clear();
         match->description_class.clear();
       }
@@ skipping 21 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }