Enabled pressing TAB to cycle through the Omnibox results.

chrome/browser/autocomplete/autocomplete.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/autocomplete.h"
 
 #include <algorithm>
+#include <set>
+#include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/i18n/number_formatting.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_controller_delegate.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/builtin_provider.h"
 #include "chrome/browser/autocomplete/extension_app_provider.h"
 #include "chrome/browser/autocomplete/history_contents_provider.h"
 #include "chrome/browser/autocomplete/history_quick_provider.h"
 #include "chrome/browser/autocomplete/history_url_provider.h"
 #include "chrome/browser/autocomplete/keyword_provider.h"
 #include "chrome/browser/autocomplete/search_provider.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/external_protocol_handler.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/search_engines/template_url.h"
+#include "chrome/browser/search_engines/template_url_model.h"
 #include "chrome/browser/ui/webui/history_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/common/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_canon_ip.h"
 #include "googleurl/src/url_util.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
@@ skipping 595 matching lines @@
       std::upper_bound(begin(), end(), match, &AutocompleteMatch::MoreRelevant);
   ACMatches::iterator::difference_type default_offset =
       default_match_ - begin();
   if ((insertion_point - begin()) <= default_offset)
     ++default_offset;
   matches_.insert(insertion_point, match);
   default_match_ = begin() + default_offset;
 }
 
 void AutocompleteResult::SortAndCull(const AutocompleteInput& input) {
+  for (ACMatches::iterator i = matches_.begin(); i != matches_.end(); ++i)
+    i->ComputeStrippedDestinationURL();
+
   // Remove duplicates.
   std::sort(matches_.begin(), matches_.end(),
             &AutocompleteMatch::DestinationSortFunc);
   matches_.erase(std::unique(matches_.begin(), matches_.end(),
                              &AutocompleteMatch::DestinationsEqual),
                  matches_.end());
 
   // Sort and trim to the most relevant kMaxMatches matches.
   const size_t num_matches = std::min(kMaxMatches, matches_.size());
   std::partial_sort(matches_.begin(), matches_.begin() + num_matches,
@@ skipping 123 matching lines @@
 // any copied entries. We do this from the time the user stopped typing as some
 // providers (such as SearchProvider) wait for the user to stop typing before
 // they initiate a query.
 static const int kExpireTimeMS = 500;
 
 AutocompleteController::AutocompleteController(
     Profile* profile,
     AutocompleteControllerDelegate* delegate)
     : delegate_(delegate),
       done_(true),
-      in_start_(false) {
+      in_start_(false),
+      profile_(profile) {
   search_provider_ = new SearchProvider(this, profile);
   providers_.push_back(search_provider_);
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHistoryQuickProvider))
     providers_.push_back(new HistoryQuickProvider(this, profile));
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableHistoryURLProvider))
     providers_.push_back(new HistoryURLProvider(this, profile));
   providers_.push_back(new KeywordProvider(this, profile));
   providers_.push_back(new HistoryContentsProvider(this, profile));
@@ skipping 14 matching lines @@
   Stop(false);
 
   for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
     (*i)->Release();
 
   providers_.clear();  // Not really necessary.
 }
 
 void AutocompleteController::SetProfile(Profile* profile) {
   Stop(true);
+  profile_ = profile;
   for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
     (*i)->SetProfile(profile);
   input_.Clear();  // Ensure we don't try to do a "minimal_changes" query on a
                    // different profile.
 }
 
 void AutocompleteController::Start(
     const string16& text,
     const string16& desired_tld,
     bool prevent_inline_autocomplete,
@@ skipping 92 matching lines @@
   AutocompleteResult last_result;
   last_result.Swap(&result_);
 
   for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
        ++i)
     result_.AppendMatches((*i)->matches());
 
   // Sort the matches and trim to a small number of "best" matches.
   result_.SortAndCull(input_);
 
+  std::set<string16> keywords;
+  for (ACMatches::iterator match(result_.begin()); match != result_.end();
+      ++match) {
+    if (match->keyword_state == AutocompleteMatch::KEYWORD) {
+      keywords.insert(match->keyword);
+    } else {
+      string16 keyword = GetKeywordForText(match->fill_into_edit);
+
+      // Only add the keyword if the match does not have a duplicate keyword
+      // with a more relevant match.
+      if (!keyword.empty() && !keywords.count(keyword)) {
+        match->keyword.assign(keyword);
+        match->keyword_state = AutocompleteMatch::DUAL_SHOWING_NON_KEYWORD;
+        match->keyword_url = profile_->GetTemplateURLModel()->
+            GetTemplateURLForKeyword(keyword);
+        keywords.insert(keyword);
+      }
+    }
+  }
+
   // Need to validate before invoking CopyOldMatches as the old matches are not
   // valid against the current input.
 #ifndef NDEBUG
   result_.Validate();
 #endif
 
   if (!done_) {
     // This conditional needs to match the conditional in Start that invokes
     // StartExpireTimer.
     result_.CopyOldMatches(input_, last_result);
@@ skipping 38 matching lines @@
     }
   }
   done_ = true;
 }
 
 void AutocompleteController::StartExpireTimer() {
   if (result_.HasCopiedMatches())
     expire_timer_.Start(base::TimeDelta::FromMilliseconds(kExpireTimeMS),
                         this, &AutocompleteController::ExpireCopiedEntries);
 }
+
+string16 AutocompleteController::GetKeywordForText(
+    const string16& text) const {
+  const string16 keyword(TemplateURLModel::CleanUserInputKeyword(text));
+
+  if (keyword.empty())
+    return keyword;
+  if (!profile_->GetTemplateURLModel())
+    return string16();
+  profile_->GetTemplateURLModel()->Load();
+
+  // Don't provide a hint if this keyword doesn't support replacement.
+  const TemplateURL* const template_url =
+      profile_->GetTemplateURLModel()->GetTemplateURLForKeyword(keyword);
+  if (!TemplateURL::SupportsReplacement(template_url))
+    return string16();
+
+  // Don't provide a hint for inactive/disabled extension keywords.
+  if (template_url->IsExtensionKeyword()) {
+    const Extension* extension = profile_->GetExtensionService()->
+        GetExtensionById(template_url->GetExtensionId(), false);
+    if (!extension ||
+       (profile_->IsOffTheRecord() &&
+       !profile_->GetExtensionService()->IsIncognitoEnabled(extension->id())))
+      return string16();
+  }
+
+  return keyword;
+}
+