Make chrome.omnibox.setDefaultSuggestion work when called inside

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"
@@ skipping 43 matching lines @@
 
 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, NotificationType::EXTENSION_OMNIBOX_SUGGESTIONS_READY,
                  Source<Profile>(profile->GetOriginalProfile()));
+  registrar_.Add(this,
+                 NotificationType::EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED,
+                 Source<Profile>(profile->GetOriginalProfile()));
   registrar_.Add(this, NotificationType::EXTENSION_OMNIBOX_INPUT_ENTERED,
                  Source<Profile>(profile));
 }
 
 KeywordProvider::KeywordProvider(ACProviderListener* listener,
                                  TemplateURLModel* model)
     : AutocompleteProvider(listener, NULL, "Keyword"),
       model_(model),
       current_input_id_(0) {
 }
@@ skipping 352 matching lines @@
                                                 ACMatchClassification::DIM,
                                                 &result.description_class);
   }
 
   return result;
 }
 
 void KeywordProvider::Observe(NotificationType type,
                               const NotificationSource& source,
                               const NotificationDetails& details) {
-  if (type == NotificationType::EXTENSION_OMNIBOX_INPUT_ENTERED) {
-    // Input has been accepted, so we're done with this input session. Ensure
-    // we don't send the OnInputCancelled event.
-    current_keyword_extension_id_.clear();
-    return;
+  TemplateURLModel* model = profile_ ? profile_->GetTemplateURLModel() : model_;
+  const AutocompleteInput& input = extension_suggest_last_input_;
+
+  switch (type.value) {
+    case NotificationType::EXTENSION_OMNIBOX_INPUT_ENTERED:
+      // Input has been accepted, so we're done with this input session. Ensure
+      // we don't send the OnInputCancelled event.
+      current_keyword_extension_id_.clear();
+      return;
+
+    case NotificationType::EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED: {
+      // It's possible to change the default suggestion while not in an editing
+      // session.
+      std::wstring keyword, remaining_input;
+      if (matches_.empty() || current_keyword_extension_id_.empty() ||
+          !ExtractKeywordFromInput(input, &keyword, &remaining_input))
+        return;
+
+      const TemplateURL* template_url(model->GetTemplateURLForKeyword(keyword));
+      ApplyDefaultSuggestionForExtensionKeyword(profile_, template_url,
+                                                WideToUTF16(remaining_input),
+                                                &matches_[0]);
+      listener_->OnProviderUpdate(true);
+      return;
+    }
+
+    case NotificationType::EXTENSION_OMNIBOX_SUGGESTIONS_READY: {
+      const ExtensionOmniboxSuggestions& suggestions =
+        *Details<ExtensionOmniboxSuggestions>(details).ptr();
+      if (suggestions.request_id != current_input_id_)
+        return;  // This is an old result. Just ignore.
+
+      std::wstring keyword, remaining_input;
+      if (!ExtractKeywordFromInput(input, &keyword, &remaining_input)) {
+        NOTREACHED();
+        return;
+      }
+
+      // TODO(mpcomplete): consider clamping the number of suggestions to
+      // AutocompleteProvider::kMaxMatches.
+      for (size_t i = 0; i < suggestions.suggestions.size(); ++i) {
+        const ExtensionOmniboxSuggestion& suggestion =
+            suggestions.suggestions[i];
+        // 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(), input.allow_exact_keyword_match());
+        extension_suggest_matches_.push_back(CreateAutocompleteMatch(
+            model, keyword, input, keyword.length(),
+            UTF16ToWide(suggestion.content), first_relevance - (i + 1)));
+
+        AutocompleteMatch* match = &extension_suggest_matches_.back();
+        match->contents.assign(UTF16ToWide(suggestion.description));
+        match->contents_class = suggestion.description_styles;
+        match->description.clear();
+        match->description_class.clear();
+      }
+
+      done_ = true;
+      matches_.insert(matches_.end(), extension_suggest_matches_.begin(),
+                      extension_suggest_matches_.end());
+      listener_->OnProviderUpdate(!extension_suggest_matches_.empty());
+      return;
+    }
+
+    default:
+      NOTREACHED();
+      return;
   }
-
-  // TODO(mpcomplete): consider clamping the number of suggestions to
-  // AutocompleteProvider::kMaxMatches.
-  DCHECK(type == NotificationType::EXTENSION_OMNIBOX_SUGGESTIONS_READY);
-
-  const ExtensionOmniboxSuggestions& suggestions =
-      *Details<ExtensionOmniboxSuggestions>(details).ptr();
-  if (suggestions.request_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_;
-
-  for (size_t i = 0; i < suggestions.suggestions.size(); ++i) {
-    const ExtensionOmniboxSuggestion& suggestion = suggestions.suggestions[i];
-    // 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(), input.allow_exact_keyword_match());
-    extension_suggest_matches_.push_back(CreateAutocompleteMatch(
-        model, keyword, input, keyword.length(),
-        UTF16ToWide(suggestion.content), first_relevance - (i + 1)));
-
-    AutocompleteMatch* match = &extension_suggest_matches_.back();
-    match->contents.assign(UTF16ToWide(suggestion.description));
-    match->contents_class = suggestion.description_styles;
-    match->description.clear();
-    match->description_class.clear();
-  }
-
-  done_ = true;
-  matches_.insert(matches_.end(), extension_suggest_matches_.begin(),
-                  extension_suggest_matches_.end());
-  listener_->OnProviderUpdate(!extension_suggest_matches_.empty());
 }
 
 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();
   }
 }