Change some functions in ImeEngineObserver as not ChromeOS-only.

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

 // Copyright 2015 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 <stddef.h>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 65 matching lines @@
 }
 
 class ImeObserverChromeOS : public ui::ImeObserver {
  public:
   ImeObserverChromeOS(const std::string& extension_id, Profile* profile)
       : ImeObserver(extension_id, profile) {}
 
   ~ImeObserverChromeOS() override {}
 
   // ui::IMEEngineObserver overrides
-  void OnActivate(const std::string& component_id) override {
-    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 OnInputContextUpdate(
       const IMEEngineHandlerInterface::InputContext& context) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnInputContextUpdate::kEventName))
       return;
 
     input_ime::InputContext context_value;
     context_value.context_id = context.id;
     context_value.type =
         input_ime::ParseInputContextType(ConvertInputContextType(context));
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnInputContextUpdate::Create(context_value));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_INPUT_CONTEXT_UPDATE,
         input_ime::OnInputContextUpdate::kEventName, std::move(args));
   }
 
-  bool IsInterestedInKeyEvent() const override {
-    return ShouldForwardKeyEvent();
-  }
-
   void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
       ui::IMEEngineObserver::MouseButtonEvent button) override {
     if (extension_id_.empty() ||
         !HasListener(input_ime::OnCandidateClicked::kEventName))
       return;
 
     input_ime::MouseButton button_enum = input_ime::MOUSE_BUTTON_NONE;
     switch (button) {
@@ skipping 27 matching lines @@
       return;
 
     scoped_ptr<base::ListValue> args(
         input_ime::OnMenuItemActivated::Create(component_id, menu_id));
 
     DispatchEventToExtension(
         extensions::events::INPUT_IME_ON_MENU_ITEM_ACTIVATED,
         input_ime::OnMenuItemActivated::kEventName, std::move(args));
   }
 
-  void OnSurroundingTextChanged(const std::string& component_id,
-                                const std::string& text,
-                                int cursor_pos,
-                                int anchor_pos,
-                                int offset_pos) override {
-    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));
-  }
-
   void OnCompositionBoundsChanged(
       const std::vector<gfx::Rect>& bounds) override {
     if (extension_id_.empty() ||
         !HasListener(kOnCompositionBoundsChangedEventName))
       return;
 
     // Note: this is a private API event.
     base::ListValue* bounds_list = new base::ListValue();
     for (size_t i = 0; i < bounds.size(); ++i) {
       base::DictionaryValue* bounds_value = new base::DictionaryValue();
@@ skipping 52 matching lines @@
     scoped_ptr<extensions::Event> event(
         new extensions::Event(histogram_value, event_name, std::move(args)));
     event->restrict_to_browser_context = profile_;
     extensions::EventRouter::Get(profile_)
         ->DispatchEventToExtension(extension_id_, std::move(event));
   }
 
   // The component IME extensions need to know the current screen type (e.g.
   // lock screen, login screen, etc.) so that its on-screen keyboard page
   // won't open new windows/pages. See crbug.com/395621.
-  std::string GetCurrentScreenType() {
+  std::string GetCurrentScreenType() override {
     switch (chromeos::input_method::InputMethodManager::Get()
                 ->GetUISessionState()) {
       case chromeos::input_method::InputMethodManager::STATE_LOGIN_SCREEN:
         return "login";
       case chromeos::input_method::InputMethodManager::STATE_LOCK_SCREEN:
         return "lock";
       case chromeos::input_method::InputMethodManager::STATE_BROWSER_SCREEN:
         return chromeos::UserAddingScreen::Get()->IsRunning()
                    ? "secondary-login"
                    : "normal";
@@ skipping 411 matching lines @@
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   engine->DeleteSurroundingText(params.context_id, params.offset, params.length,
                                 &error_);
   return true;
 }
 
 }  // namespace extensions