Makes the omnibox show past searches and suggestions for keywords....

chrome/browser/autocomplete/keyword_provider.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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/string_util.h"
 #include "chrome/browser/profile.h"
@@ skipping 42 matching lines @@
   // always put any exact matches first no matter what, since the code in
   // Start() assumes this (and it makes sense).
   bool operator()(const std::wstring& keyword1,
                   const std::wstring& keyword2) const {
     return keyword1.length() < keyword2.length();
   }
 };
 
 }  // namespace
 
+// static
+const TemplateURL* KeywordProvider::GetSubstitutingTemplateURLForInput(
+    Profile* profile,
+    const AutocompleteInput& input,
+    std::wstring* remaining_input) {
+  std::wstring 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.
+  TemplateURLModel* model = profile->GetTemplateURLModel();
+  DCHECK(model);
+  model->Load();
+
+  const TemplateURL* template_url = model->GetTemplateURLForKeyword(keyword);
+  return TemplateURL::SupportsReplacement(template_url) ? template_url : NULL;
+}
+
 void KeywordProvider::Start(const AutocompleteInput& input,
                             bool minimal_changes) {
   matches_.clear();
 
-  if ((input.type() == AutocompleteInput::INVALID) ||
-      (input.type() == AutocompleteInput::FORCED_QUERY))
-    return;
-
   // Split user input into a keyword and some query input.
   //
   // We want to suggest keywords even when users have started typing URLs, on
   // the assumption that they might not realize they no longer need to go to a
   // site to be able to search it.  So we call CleanUserInputKeyword() to strip
   // any initial scheme and/or "www.".  NOTE: Any heuristics or UI used to
   // automatically/manually create keywords will need to be in sync with
   // 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.
-  std::wstring remaining_input;
-  std::wstring keyword(TemplateURLModel::CleanUserInputKeyword(
-      SplitKeywordFromInput(input.text(), &remaining_input)));
-  if (keyword.empty())
+  std::wstring keyword, remaining_input;
+  if (!ExtractKeywordFromInput(input, &keyword, &remaining_input))
     return;
 
   // Make sure the model is loaded. This is cheap and quickly bails out if
   // the model is already loaded.
   TemplateURLModel* model = profile_ ? profile_->GetTemplateURLModel() : model_;
   DCHECK(model);
   model->Load();
 
   // Get the best matches for this keyword.
   //
@@ skipping 28 matching lines @@
     for (std::vector<std::wstring>::const_iterator i(keyword_matches.begin());
          i != keyword_matches.end(); ++i) {
       matches_.push_back(CreateAutocompleteMatch(model, *i, input,
                                                  keyword.length(),
                                                  remaining_input));
     }
   }
 }
 
 // static
+bool KeywordProvider::ExtractKeywordFromInput(const AutocompleteInput& input,
+                                              std::wstring* keyword,
+                                              std::wstring* remaining_input) {
+  if ((input.type() == AutocompleteInput::INVALID) ||
+      (input.type() == AutocompleteInput::FORCED_QUERY))
+    return false;
+
+  *keyword = TemplateURLModel::CleanUserInputKeyword(
+      SplitKeywordFromInput(input.text(), remaining_input));
+  return !keyword->empty();
+}
+
+// static
 std::wstring KeywordProvider::SplitKeywordFromInput(
     const std::wstring& input,
     std::wstring* 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(kWhitespaceWide));
   DCHECK(first_white != 0);
   if (first_white == std::wstring::npos)
     return input;  // Only one token provided.
 
@@ skipping 128 matching lines @@
                                               prefix_length,
                                               result.description.length(),
                                               ACMatchClassification::DIM,
                                               &result.description_class);
 
   // Keyword searches don't look like URLs.
   result.transition = PageTransition::GENERATED;
 
   return result;
 }