First pass at experimental omnibox API. There are plenty of rough edges and

chrome/browser/autocomplete/keyword_provider.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
+#include "base/string16.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/extensions/extension_omnibox_api.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
+#include "chrome/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 
 // static
 std::wstring KeywordProvider::SplitReplacementStringFromInput(
     const std::wstring& input) {
   // The input may contain leading whitespace, strip it.
   std::wstring trimmed_input;
   TrimWhitespace(input, TRIM_LEADING, &trimmed_input);
 
   // And extract the replacement string.
   std::wstring remaining_input;
   SplitKeywordFromInput(trimmed_input, &remaining_input);
   return remaining_input;
 }
 
 KeywordProvider::KeywordProvider(ACProviderListener* listener, Profile* profile)
     : AutocompleteProvider(listener, profile, "Keyword"),
-      model_(NULL) {
+      model_(NULL),
+      current_input_id_(0) {
+  registrar_.Add(this, NotificationType::EXTENSION_OMNIBOX_SUGGESTIONS_READY,
+                 Source<Profile>(profile));
 }
 
 KeywordProvider::KeywordProvider(ACProviderListener* listener,
                                  TemplateURLModel* model)
     : AutocompleteProvider(listener, NULL, "Keyword"),
-      model_(model) {
+      model_(model),
+      current_input_id_(0) {
 }
 
 
 namespace {
 
 // Helper functor for Start(), for sorting keyword matches by quality.
 class CompareQuality {
  public:
   // A keyword is of higher quality when a greater fraction of it has been
   // typed, that is, when it is shorter.
@@ skipping 26 matching lines @@
   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 (!minimal_changes) {
+    done_ = true;
+
+    // Input has changed. Increment the input ID so that we can discard any
+    // stale extension suggestions that may be incoming.
+    ++current_input_id_;
+  }
+
   // 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
@@ skipping 27 matching lines @@
     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.
   if (keyword_matches.front() == keyword) {
     matches_.push_back(CreateAutocompleteMatch(model, keyword, input,
                                                keyword.length(),
-                                               remaining_input));
+                                               remaining_input, -1));
+
+    const TemplateURL* template_url(model->GetTemplateURLForKeyword(keyword));
+    if (profile_ &&
+        !input.synchronous_only() && template_url->IsExtensionKeyword()) {
+      if (minimal_changes) {
+        // If the input hasn't significantly changed, we can just use the
+        // suggestions from last time. We need to readjust the relevance to
+        // ensure it is less than the main match's relevance.
+        for (size_t i = 0; i < extension_suggest_matches_.size(); ++i) {
+          matches_.push_back(extension_suggest_matches_[i]);
+          matches_.back().relevance = matches_[0].relevance - (i + 1);
+        }
+      } else {
+        extension_suggest_last_input_ = input;
+        extension_suggest_matches_.clear();
+
+        bool have_listeners = ExtensionOmniboxEventRouter::OnInputChanged(
+            profile_, template_url->GetExtensionId(),
+            WideToUTF8(remaining_input), current_input_id_);
+
+        // We only have to wait for suggest results if there are actually
+        // extensions listening for input changes.
+        if (have_listeners)
+          done_ = false;
+      }
+    }
   } else {
     if (keyword_matches.size() > kMaxMatches) {
       keyword_matches.erase(keyword_matches.begin() + kMaxMatches,
                             keyword_matches.end());
     }
     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));
+                                                 remaining_input, -1));
     }
   }
 }
 
 // static
 bool KeywordProvider::ExtractKeywordFromInput(const AutocompleteInput& input,
                                               std::wstring* keyword,
                                               std::wstring* remaining_input) {
   if ((input.type() == AutocompleteInput::INVALID) ||
       (input.type() == AutocompleteInput::FORCED_QUERY))
@@ skipping 27 matching lines @@
 }
 
 // static
 void KeywordProvider::FillInURLAndContents(
     const std::wstring& 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;
   if (remaining_input.empty()) {
     if (element->url()->SupportsReplacement()) {
       // No query input; return a generic, no-destination placeholder.
-      match->contents.assign(l10n_util::GetStringF(IDS_KEYWORD_SEARCH,
+      match->contents.assign(l10n_util::GetStringF(message_id,
           element->AdjustedShortNameForLocaleDirection(),
           l10n_util::GetString(IDS_EMPTY_KEYWORD_VALUE)));
       match->contents_class.push_back(
           ACMatchClassification(0, ACMatchClassification::DIM));
     } else {
       // Keyword that has no replacement text (aka a shorthand for a URL).
       match->destination_url = GURL(WideToUTF8(element->url()->url()));
       match->contents.assign(element->short_name());
       AutocompleteMatch::ClassifyLocationInString(0, match->contents.length(),
           match->contents.length(), ACMatchClassification::NONE,
           &match->contents_class);
     }
   } else {
     // Create destination URL by escaping user input and substituting into
     // keyword template URL.  The escaping here handles whitespace in user
     // input, but we rely on later canonicalization functions to do more
     // fixup to make the URL valid if necessary.
     DCHECK(element->url()->SupportsReplacement());
     match->destination_url = GURL(WideToUTF8(element->url()->ReplaceSearchTerms(
       *element, remaining_input, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE,
       std::wstring())));
     std::vector<size_t> content_param_offsets;
-    match->contents.assign(l10n_util::GetStringF(IDS_KEYWORD_SEARCH,
+    match->contents.assign(l10n_util::GetStringF(message_id,
                                                  element->short_name(),
                                                  remaining_input,
                                                  &content_param_offsets));
     if (content_param_offsets.size() == 2) {
       AutocompleteMatch::ClassifyLocationInString(content_param_offsets[1],
           remaining_input.length(), match->contents.length(),
           ACMatchClassification::NONE, &match->contents_class);
     } else {
       // See comments on an identical NOTREACHED() in search_provider.cc.
       NOTREACHED();
@@ skipping 10 matching lines @@
   if (no_query_text_needed)
     return 1500;
   return (type == AutocompleteInput::QUERY) ? 1450 : 1100;
 }
 
 AutocompleteMatch KeywordProvider::CreateAutocompleteMatch(
     TemplateURLModel* model,
     const std::wstring keyword,
     const AutocompleteInput& input,
     size_t prefix_length,
-    const std::wstring& remaining_input) {
+    const std::wstring& 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());
-  AutocompleteMatch result(this,
-      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),
-      false, supports_replacement ? AutocompleteMatch::SEARCH_OTHER_ENGINE :
-                                    AutocompleteMatch::HISTORY_KEYWORD);
+  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);
+  }
+  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 (!input.prevent_inline_autocomplete() &&
       (keyword_complete || remaining_input.empty()))
     result.inline_autocomplete_offset = input.text().length();
 
   // Create destination URL and popup entry content by substituting user input
   // into keyword templates.
   FillInURLAndContents(remaining_input, element, &result);
 
   // Create popup entry description based on the keyword name.
-  result.description.assign(l10n_util::GetStringF(
-      IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION, keyword));
+  int message_id = element->IsExtensionKeyword() ?
+      IDS_AUTOCOMPLETE_EXTENSION_KEYWORD_DESCRIPTION :
+      IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION;
+  result.description.assign(l10n_util::GetStringF(message_id, keyword));
   if (supports_replacement)
     result.template_url = element;
-  static const std::wstring kKeywordDesc(l10n_util::GetString(
-      IDS_AUTOCOMPLETE_KEYWORD_DESCRIPTION));
+  static const std::wstring kKeywordDesc(l10n_util::GetString(message_id));
   AutocompleteMatch::ClassifyLocationInString(kKeywordDesc.find(L"%s"),
                                               prefix_length,
                                               result.description.length(),
                                               ACMatchClassification::DIM,
                                               &result.description_class);
 
   result.transition = PageTransition::KEYWORD;
 
   return result;
 }
+
+void KeywordProvider::Observe(NotificationType type,
+                              const NotificationSource& source,
+                              const NotificationDetails& details) {
+  // TODO(mpcomplete): consider clamping the number of suggestions to
+  // AutocompleteProvider::kMaxMatches.
+  DCHECK(type == NotificationType::EXTENSION_OMNIBOX_SUGGESTIONS_READY);
+
+  int suggest_id = Details<ExtensionOmniboxSuggestions>(details).ptr()->first;
+  if (suggest_id != current_input_id_)
+    return;  // This is an old result. Just ignore.
+
+  const AutocompleteInput& input = extension_suggest_last_input_;
+  std::wstring keyword, remaining_input;
+  if (!ExtractKeywordFromInput(input, &keyword, &remaining_input)) {
+    NOTREACHED();
+    return;
+  }
+
+  TemplateURLModel* model =
+      profile_ ? profile_->GetTemplateURLModel() : model_;
+
+  ListValue* suggestions =
+      Details<ExtensionOmniboxSuggestions>(details).ptr()->second;
+  for (size_t i = 0; i < suggestions->GetSize(); ++i) {
+    DictionaryValue* suggestion;
+    string16 content, description;
+    if (!suggestions->GetDictionary(i, &suggestion) ||
+        !suggestion->GetString("content", &content) ||
+        !suggestion->GetString("description", &description))
+      break;
+
+    // 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());
+    extension_suggest_matches_.push_back(CreateAutocompleteMatch(
+        model, keyword, input, keyword.length(), UTF16ToWide(content),
+        first_relevance - (i + 1)));
+
+    if (!description.empty()) {
+      AutocompleteMatch* match = &extension_suggest_matches_.back();
+      std::vector<size_t> offsets;
+      match->contents.assign(l10n_util::GetStringF(
+          IDS_AUTOCOMPLETE_EXTENSION_KEYWORD_CONTENT,
+          match->contents, UTF16ToWide(description), &offsets));
+      CHECK_EQ(2U, offsets.size()) <<
+          "Expected 2 params for IDS_AUTOCOMPLETE_EXTENSION_KEYWORD_CONTENT";
+      match->contents_class.push_back(
+          ACMatchClassification(offsets[1], ACMatchClassification::NONE));
+    }
+  }
+
+  done_ = true;
+  matches_.insert(matches_.end(), extension_suggest_matches_.begin(),
+                  extension_suggest_matches_.end());
+  listener_->OnProviderUpdate(!extension_suggest_matches_.empty());
+}