Revert 122412 - Enabled pressing TAB to traverse 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 24 matching lines @@
       provider_->MaybeEndExtensionKeywordMode();
   }
 
   void StayInKeywordMode() {
     provider_ = NULL;
   }
  private:
   KeywordProvider* provider_;
 };
 
+// static
+string16 KeywordProvider::SplitReplacementStringFromInput(
+    const string16& input,
+    bool trim_leading_whitespace) {
+  // The input may contain leading whitespace, strip it.
+  string16 trimmed_input;
+  TrimWhitespace(input, TRIM_LEADING, &trimmed_input);
+
+  // And extract the replacement string.
+  string16 remaining_input;
+  SplitKeywordFromInput(trimmed_input, trim_leading_whitespace,
+                        &remaining_input);
+  return remaining_input;
+}
+
 KeywordProvider::KeywordProvider(ACProviderListener* listener, Profile* profile)
     : AutocompleteProvider(listener, profile, "Keyword"),
       model_(NULL),
       current_input_id_(0) {
   // Extension suggestions always come from the original profile, since that's
   // where extensions run. We use the input ID to distinguish whether the
   // suggestions are meant for us.
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY,
                  content::Source<Profile>(profile->GetOriginalProfile()));
@@ skipping 30 matching lines @@
   }
 };
 
 // We need our input IDs to be unique across all profiles, so we keep a global
 // UID that each provider uses.
 static int global_input_uid_;
 
 }  // namespace
 
 // static
-string16 KeywordProvider::SplitKeywordFromInput(
-    const string16& input,
-    bool trim_leading_whitespace,
-    string16* remaining_input) {
-  // Find end of first token.  The AutocompleteController has trimmed leading
-  // whitespace, so we need not skip over that.
-  const size_t first_white(input.find_first_of(kWhitespaceUTF16));
-  DCHECK_NE(0U, first_white);
-  if (first_white == string16::npos)
-    return input;  // Only one token provided.
-
-  // Set |remaining_input| to everything after the first token.
-  DCHECK(remaining_input != NULL);
-  const size_t remaining_start = trim_leading_whitespace ?
-      input.find_first_not_of(kWhitespaceUTF16, first_white) : first_white + 1;
-
-  if (remaining_start < input.length())
-    remaining_input->assign(input.begin() + remaining_start, input.end());
-
-  // Return first token as keyword.
-  return input.substr(0, first_white);
-}
-
-// static
-string16 KeywordProvider::SplitReplacementStringFromInput(
-    const string16& input,
-    bool trim_leading_whitespace) {
-  // The input may contain leading whitespace, strip it.
-  string16 trimmed_input;
-  TrimWhitespace(input, TRIM_LEADING, &trimmed_input);
-
-  // And extract the replacement string.
-  string16 remaining_input;
-  SplitKeywordFromInput(trimmed_input, trim_leading_whitespace,
-      &remaining_input);
-  return remaining_input;
-}
-
-// static
 const TemplateURL* KeywordProvider::GetSubstitutingTemplateURLForInput(
     Profile* profile,
     const AutocompleteInput& input,
     string16* remaining_input) {
   if (!input.allow_exact_keyword_match())
     return NULL;
 
   string16 keyword;
   if (!ExtractKeywordFromInput(input, &keyword, remaining_input))
     return NULL;
 
   // Make sure the model is loaded. This is cheap and quickly bails out if
   // the model is already loaded.
   TemplateURLService* model = TemplateURLServiceFactory::GetForProfile(profile);
   DCHECK(model);
   model->Load();
 
   const TemplateURL* template_url = model->GetTemplateURLForKeyword(keyword);
   return TemplateURL::SupportsReplacement(template_url) ? template_url : NULL;
 }
 
-string16 KeywordProvider::GetKeywordForText(
-    const string16& text) const {
-  const string16 keyword(TemplateURLService::CleanUserInputKeyword(text));
-
-  if (keyword.empty())
-    return keyword;
-
-  TemplateURLService* url_service = GetTemplateURLService();
-  if (!url_service)
-    return string16();
-
-  // Don't provide a keyword if it doesn't support replacement.
-  const TemplateURL* const template_url =
-      url_service->GetTemplateURLForKeyword(keyword);
-  if (!TemplateURL::SupportsReplacement(template_url))
-    return string16();
-
-  // Don't provide a keyword 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;
-}
-
-AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
-    const string16& text,
-    const string16& keyword,
-    const AutocompleteInput& input) {
-  return CreateAutocompleteMatch(GetTemplateURLService(), keyword, input,
-      keyword.size(), SplitReplacementStringFromInput(text, 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();
 
   if (!minimal_changes) {
     done_ = true;
@@ skipping 13 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;
 
-  TemplateURLService* model = GetTemplateURLService();
+  // Make sure the model is loaded. This is cheap and quickly bails out if
+  // 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) &&
-        remaining_input.empty() && !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 70 matching lines @@
     return false;
 
   string16 trimmed_input;
   TrimWhitespace(input.text(), TRIM_TRAILING, &trimmed_input);
   *keyword = TemplateURLService::CleanUserInputKeyword(
       SplitKeywordFromInput(trimmed_input, true, remaining_input));
   return !keyword->empty();
 }
 
 // static
+string16 KeywordProvider::SplitKeywordFromInput(
+    const string16& input,
+    bool trim_leading_whitespace,
+    string16* remaining_input) {
+  // Find end of first token.  The AutocompleteController has trimmed leading
+  // whitespace, so we need not skip over that.
+  const size_t first_white(input.find_first_of(kWhitespaceUTF16));
+  DCHECK_NE(0U, first_white);
+  if (first_white == string16::npos)
+    return input;  // Only one token provided.
+
+  // Set |remaining_input| to everything after the first token.
+  DCHECK(remaining_input != NULL);
+  const size_t remaining_start = trim_leading_whitespace ?
+      input.find_first_not_of(kWhitespaceUTF16, first_white) : first_white + 1;
+
+  if (remaining_start < input.length())
+    remaining_input->assign(input.begin() + remaining_start, input.end());
+
+  // Return first token as keyword.
+  return input.substr(0, first_white);
+}
+
+// static
 void KeywordProvider::FillInURLAndContents(
     Profile* profile,
     const string16& remaining_input,
     const TemplateURL* element,
     AutocompleteMatch* match) {
   DCHECK(!element->short_name().empty());
   DCHECK(element->url());
   DCHECK(element->url()->IsValid());
   int message_id = element->IsExtensionKeyword() ?
       IDS_EXTENSION_KEYWORD_COMMAND : IDS_KEYWORD_SEARCH;
@@ skipping 77 matching lines @@
   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,
+  AutocompleteMatch result(this, relevance, false,
       supports_replacement ? AutocompleteMatch::SEARCH_OTHER_ENGINE :
                              AutocompleteMatch::HISTORY_KEYWORD);
-  match.fill_into_edit.assign(keyword);
+  result.fill_into_edit.assign(keyword);
   if (!remaining_input.empty() || !keyword_complete || supports_replacement)
-    match.fill_into_edit.push_back(L' ');
-  match.fill_into_edit.append(remaining_input);
+    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.
-  match.inline_autocomplete_offset = string16::npos;
+  result.inline_autocomplete_offset = string16::npos;
 
   // Create destination URL and popup entry content by substituting user input
   // into keyword templates.
-  FillInURLAndContents(profile_, remaining_input, element, &match);
+  FillInURLAndContents(profile_, remaining_input, element, &result);
 
   if (supports_replacement)
-    match.template_url = element;
-  match.keyword = keyword;
-  match.transition = content::PAGE_TRANSITION_KEYWORD;
+    result.template_url = element;
+  result.transition = content::PAGE_TRANSITION_KEYWORD;
 
-  return match;
+  return result;
 }
 
 void KeywordProvider::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
-  TemplateURLService* model = GetTemplateURLService();
+  TemplateURLService* model =
+      profile_ ? TemplateURLServiceFactory::GetForProfile(profile_) : model_;
   const AutocompleteInput& input = extension_suggest_last_input_;
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_OMNIBOX_INPUT_ENTERED:
       // Input has been accepted, so we're done with this input session. Ensure
       // we don't send the OnInputCancelled event, or handle any more stray
       // suggestions_ready events.
       current_keyword_extension_id_.clear();
       current_input_id_ = 0;
       return;
@@ skipping 56 matching lines @@
       listener_->OnProviderUpdate(!extension_suggest_matches_.empty());
       return;
     }
 
     default:
       NOTREACHED();
       return;
   }
 }
 
-TemplateURLService* KeywordProvider::GetTemplateURLService() const {
-  TemplateURLService* service = profile_ ?
-      TemplateURLServiceFactory::GetForProfile(profile_) : model_;
-  // Make sure the model is loaded. This is cheap and quickly bails out if
-  // the model is already loaded.
-  DCHECK(service);
-  service->Load();
-  return service;
-}
-
 void KeywordProvider::EnterExtensionKeywordMode(
     const std::string& extension_id) {
   DCHECK(current_keyword_extension_id_.empty());
   current_keyword_extension_id_ = extension_id;
 
   ExtensionOmniboxEventRouter::OnInputStarted(
       profile_, current_keyword_extension_id_);
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }