Enabled pressing TAB to cycle through the Omnibox results.

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 143 matching lines @@
   // whatever we do here!
   //
   // TODO(pkasting): http://b/1112681 If someday we remember usage frequency for
   // keywords, we might suggest keywords that haven't even been partially typed,
   // if the user uses them enough and isn't obviously typing something else.  In
   // this case we'd consider all input here to be query input.
   string16 keyword, remaining_input;
   if (!ExtractKeywordFromInput(input, &keyword, &remaining_input))
     return;
 
   // Make sure the model is loaded. This is cheap and quickly bails out if

[Peter Kasting, 2011/07/27 20:18:25]

Nit: I think we should factor this into some public getter function that this
function, CreateAutocompleteMatch(), and Observe() all call.  Then
CreateAutocompleteMatch() can avoid taking this as an arg, and
AutocompleteController::GetKeywordForText() can call this as well, eliminating
the need for AutocompleteController to track the profile.

   // the model is already loaded.
   TemplateURLService* model =
       profile_ ?
       TemplateURLServiceFactory::GetForProfile(profile_) :
       model_;
   DCHECK(model);
   model->Load();
 
   // Get the best matches for this keyword.
   //
   // NOTE: We could cache the previous keywords and reuse them here in the
   // |minimal_changes| case, but since we'd still have to recalculate their
   // relevances and we can just recreate the results synchronously anyway, we
   // don't bother.
   //
   // TODO(pkasting): http://b/893701 We should remember the user's use of a
   // search query both from the autocomplete popup and from web pages
   // themselves.
   std::vector<string16> keyword_matches;
   model->FindMatchingKeywords(keyword,
                               !remaining_input.empty(),
                               &keyword_matches);
 
-  // Prune any extension keywords that are disallowed in incognito mode (if
-  // we're incognito), or disabled.
   for (std::vector<string16>::iterator i(keyword_matches.begin());
        i != keyword_matches.end(); ) {
     const TemplateURL* template_url(model->GetTemplateURLForKeyword(*i));
+
+    // Prune any extension keywords that are disallowed in incognito mode (if
+    // we're incognito), or disabled.
     if (profile_ &&
         input.matches_requested() == AutocompleteInput::ALL_MATCHES &&
         template_url->IsExtensionKeyword()) {
       ExtensionService* service = profile_->GetExtensionService();
       const Extension* extension = service->GetExtensionById(
           template_url->GetExtensionId(), false);
       bool enabled =
           extension && (!profile_->IsOffTheRecord() ||
                         service->IsIncognitoEnabled(extension->id()));
       if (!enabled) {
         i = keyword_matches.erase(i);
         continue;
       }
     }
+
+    // Prune any substituting keywords if there is no substitution.
+    if (TemplateURL::SupportsReplacement(template_url) &&
+        !input.allow_exact_keyword_match()) {
+      i = keyword_matches.erase(i);
+      continue;
+    }
+
     ++i;
   }
   if (keyword_matches.empty())
     return;
   std::sort(keyword_matches.begin(), keyword_matches.end(), CompareQuality());
 
   // Limit to one exact or three inexact matches, and mark them up for display
   // in the autocomplete popup.
   // Any exact match is going to be the highest quality match, and thus at the
   // front of our vector.
@@ skipping 166 matching lines @@
     return (type == AutocompleteInput::URL) ? 700 : 450;
   if (!supports_replacement || (allow_exact_keyword_match && prefer_keyword))
     return 1500;
   return (allow_exact_keyword_match && (type == AutocompleteInput::QUERY)) ?
       1450 : 1100;
 }
 
 AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
     TemplateURLService* model,
     const string16& keyword,
+    const AutocompleteInput& input) {
+  return CreateAutocompleteMatch(model, keyword, input, keyword.size(),
+      string16(), 0);
+}
+
+AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
+    TemplateURLService* 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.
                            supports_replacement, input.prefer_keyword(),
                            input.allow_exact_keyword_match());
   }
   AutocompleteMatch result(this, relevance, false,

[Peter Kasting, 2011/07/27 20:18:25]

Nit: While you're here, can you rename |result| to |match|?  It's really
confusing to see "result" since I expect it to be type AutocompleteResult...

       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
   // 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.
   result.inline_autocomplete_offset = string16::npos;
 
   // Create destination URL and popup entry content by substituting user input
   // into keyword templates.
   FillInURLAndContents(remaining_input, element, &result);
 
-  if (supports_replacement)

[Peter Kasting, 2011/07/27 20:18:25]

Do you know why the old code had this conditional?  Or alternately, why did you
need to remove it?

[aaron.randolph, 2011/07/28 16:01:55]

I think this may have been an artifact of some earlier changes.  I've restored
it in the next update with no ill effects so far.

-    result.template_url = element;
+  result.template_url = element;
+  result.keyword = keyword;
   result.transition = PageTransition::KEYWORD;
 
   return result;
 }
 
 void KeywordProvider::Observe(int type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
   TemplateURLService* model =
       profile_ ? TemplateURLServiceFactory::GetForProfile(profile_) : model_;
@@ skipping 83 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }