Change some functions in ImeEngineObserver as not ChromeOS-only.

chrome/browser/extensions/api/input_ime/input_ime_api.cc

 // Copyright (c) 2012 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/extensions/api/input_ime/input_ime_api.h"
 
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "chrome/common/extensions/api/input_ime/input_components_handler.h"
 #include "extensions/browser/extension_registry.h"
 
 namespace input_ime = extensions::api::input_ime;
 namespace KeyEventHandled = extensions::api::input_ime::KeyEventHandled;
 using ui::IMEEngineHandlerInterface;
 
 namespace ui {
 
 ImeObserver::ImeObserver(const std::string& extension_id, Profile* profile)
     : extension_id_(extension_id), profile_(profile) {}
 
+void ImeObserver::OnActivate(const std::string& component_id) {
+  if (extension_id_.empty() || !HasListener(input_ime::OnActivate::kEventName))
+    return;
+
+  scoped_ptr<base::ListValue> args(input_ime::OnActivate::Create(
+    component_id,
+    input_ime::ParseScreenType(GetCurrentScreenType())));
+
+  DispatchEventToExtension(extensions::events::INPUT_IME_ON_ACTIVATE,
+                           input_ime::OnActivate::kEventName,
+                           std::move(args));
+}
+
 void ImeObserver::OnFocus(
     const IMEEngineHandlerInterface::InputContext& context) {
   if (extension_id_.empty() || !HasListener(input_ime::OnFocus::kEventName))
     return;
 
   input_ime::InputContext context_value;
   context_value.context_id = context.id;
   context_value.type =
       input_ime::ParseInputContextType(ConvertInputContextType(context));
   context_value.auto_correct = ConvertInputContextAutoCorrect(context);
@@ skipping 75 matching lines @@
   DispatchEventToExtension(extensions::events::INPUT_IME_ON_DEACTIVATED,
                            input_ime::OnDeactivated::kEventName,
                            std::move(args));
 }
 
 // TODO(azurewei): This function implementation should be shared on all
 // platforms, while with some changing on the current code on ChromeOS.
 void ImeObserver::OnCompositionBoundsChanged(
     const std::vector<gfx::Rect>& bounds) {}
 
+bool ImeObserver::IsInterestedInKeyEvent() const {
+  return ShouldForwardKeyEvent();
+}
+
+void ImeObserver::OnSurroundingTextChanged(const std::string& component_id,
+                                           const std::string& text,
+                                           int cursor_pos,
+                                           int anchor_pos,
+                                           int offset_pos) {
+  if (extension_id_.empty() ||
+      !HasListener(input_ime::OnSurroundingTextChanged::kEventName))
+    return;
+
+  input_ime::OnSurroundingTextChanged::SurroundingInfo info;
+  info.text = text;
+  info.focus = cursor_pos;
+  info.anchor = anchor_pos;
+  info.offset = offset_pos;
+  scoped_ptr<base::ListValue> args(
+    input_ime::OnSurroundingTextChanged::Create(component_id, info));
+
+  DispatchEventToExtension(
+    extensions::events::INPUT_IME_ON_SURROUNDING_TEXT_CHANGED,
+    input_ime::OnSurroundingTextChanged::kEventName, std::move(args));
+}
+
 bool ImeObserver::ShouldForwardKeyEvent() const {
   // Only forward key events to extension if there are non-lazy listeners
   // for onKeyEvent. Because if something wrong with the lazy background
   // page which doesn't register listener for onKeyEvent, it will not handle
   // the key events, and therefore, all key events will be eaten.
   // This is for error-tolerance, and it means that onKeyEvent will never wake
   // up lazy background page.
   const extensions::EventListenerMap::ListenerList& listener_list =
       extensions::EventRouter::Get(profile_)
           ->listeners()
@@ skipping 193 matching lines @@
 }
 
 InputImeEventRouter* GetInputImeEventRouter(Profile* profile) {
   if (profile->HasOffTheRecordProfile())
     profile = profile->GetOffTheRecordProfile();
   return extensions::InputImeEventRouterFactory::GetInstance()->GetRouter(
       profile);
 }
 
 }  // namespace extensions