Add support for omnibox.onInputStarted and onInputCancelled.

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/extensions/extensions_service.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"
 
+// Helper functor for Start(), for ending keyword mode unless explicitly told
+// otherwise.
+class KeywordProvider::ScopedEndExtensionKeywordMode {
+ public:
+  ScopedEndExtensionKeywordMode(KeywordProvider* provider)
+      : provider_(provider) { }
+  ~ScopedEndExtensionKeywordMode() {
+    if (provider_)
+      provider_->MaybeEndExtensionKeywordMode();
+  }
+
+  void StayInKeywordMode() {
+    provider_ = NULL;
+  }
+ private:
+  KeywordProvider* provider_;
+};
+
 // 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),
       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_INPUT_ENTERED,
+                 Source<Profile>(profile));
 }
 
 KeywordProvider::KeywordProvider(ACProviderListener* listener,
                                  TemplateURLModel* model)
     : AutocompleteProvider(listener, NULL, "Keyword"),
       model_(model),
       current_input_id_(0) {
 }
 
 
@@ skipping 35 matching lines @@
   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) {
+  // 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;
 
     // Input has changed. Increment the input ID so that we can discard any
     // stale extension suggestions that may be incoming.
     current_input_id_ = ++global_input_uid_;
   }
 
@@ skipping 48 matching lines @@
       // If this extension keyword is disabled, make sure we don't add any
       // matches (including the synchronous one below).
       ExtensionsService* service = profile_->GetExtensionsService();
       Extension* extension = service->GetExtensionById(
           template_url->GetExtensionId(), false);
       bool enabled = extension && (!profile_->IsOffTheRecord() ||
                                    service->IsIncognitoEnabled(extension));
       if (!enabled)
         return;
 
+      if (extension->id() != current_keyword_extension_id_)
+        MaybeEndExtensionKeywordMode();
+      if (current_keyword_extension_id_.empty())
+        EnterExtensionKeywordMode(extension->id());
+      keyword_mode_toggle.StayInKeywordMode();
+
       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;
@@ skipping 20 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, -1));
     }
   }
 }
 
+void KeywordProvider::Stop() {
+  done_ = true;
+  MaybeEndExtensionKeywordMode();
+}
+
 // 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));
@@ skipping 140 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;
+  }
+
   // 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_;
@@ skipping 24 matching lines @@
     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();
+  }
+}