Move the local struct definitions off ui/base/ime.

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 20 matching lines @@
 namespace HideInputView = extensions::api::input_ime::HideInputView;
 namespace SetMenuItems = extensions::api::input_ime::SetMenuItems;
 namespace SetCursorPosition = extensions::api::input_ime::SetCursorPosition;
 namespace SetCandidates = extensions::api::input_ime::SetCandidates;
 namespace SetCandidateWindowProperties =
     extensions::api::input_ime::SetCandidateWindowProperties;
 namespace CommitText = extensions::api::input_ime::CommitText;
 namespace ClearComposition = extensions::api::input_ime::ClearComposition;
 namespace SetComposition = extensions::api::input_ime::SetComposition;
 using ui::IMEEngineHandlerInterface;
+using input_method::InputMethodEngineBase;
+using chromeos::InputMethodEngine;
 
 namespace {
 const char kErrorEngineNotAvailable[] = "Engine is not available";
 const char kErrorSetMenuItemsFail[] = "Could not create menu Items";
 const char kErrorUpdateMenuItemsFail[] = "Could not update menu Items";
 const char kOnCompositionBoundsChangedEventName[] =
     "inputMethodPrivate.onCompositionBoundsChanged";
 
 void SetMenuItemToMenu(const input_ime::MenuItem& input,
-                       IMEEngineHandlerInterface::MenuItem* out) {
+                       InputMethodEngine::MenuItem* out) {
   out->modified = 0;
   out->id = input.id;
   if (input.label) {
-    out->modified |= IMEEngineHandlerInterface::MENU_ITEM_MODIFIED_LABEL;
+    out->modified |= InputMethodEngine::MENU_ITEM_MODIFIED_LABEL;
     out->label = *input.label;
   }
 
   if (input.style != input_ime::MENU_ITEM_STYLE_NONE) {
-    out->modified |= IMEEngineHandlerInterface::MENU_ITEM_MODIFIED_STYLE;
-    out->style =
-        static_cast<IMEEngineHandlerInterface::MenuItemStyle>(input.style);
+    out->modified |= InputMethodEngine::MENU_ITEM_MODIFIED_STYLE;
+    out->style = static_cast<InputMethodEngine::MenuItemStyle>(input.style);
   }
 
   if (input.visible)
-    out->modified |= IMEEngineHandlerInterface::MENU_ITEM_MODIFIED_VISIBLE;
+    out->modified |= InputMethodEngine::MENU_ITEM_MODIFIED_VISIBLE;
   out->visible = input.visible ? *input.visible : true;
 
   if (input.checked)
-    out->modified |= IMEEngineHandlerInterface::MENU_ITEM_MODIFIED_CHECKED;
+    out->modified |= InputMethodEngine::MENU_ITEM_MODIFIED_CHECKED;
   out->checked = input.checked ? *input.checked : false;
 
   if (input.enabled)
-    out->modified |= IMEEngineHandlerInterface::MENU_ITEM_MODIFIED_ENABLED;
+    out->modified |= InputMethodEngine::MENU_ITEM_MODIFIED_ENABLED;
   out->enabled = input.enabled ? *input.enabled : true;
 }
 
 class ImeObserverChromeOS : public ui::ImeObserver {
  public:
   ImeObserverChromeOS(const std::string& extension_id, Profile* profile)
       : ImeObserver(extension_id, profile) {}
 
   ~ImeObserverChromeOS() override {}
 
-  // ui::IMEEngineObserver overrides
+  // input_method::InputMethodEngineBase::Observer overrides.
   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));
   }
 
   void OnCandidateClicked(
       const std::string& component_id,
       int candidate_id,
-      ui::IMEEngineObserver::MouseButtonEvent button) override {
+      InputMethodEngineBase::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) {
-      case ui::IMEEngineObserver::MOUSE_BUTTON_MIDDLE:
+      case InputMethodEngineBase::MOUSE_BUTTON_MIDDLE:
         button_enum = input_ime::MOUSE_BUTTON_MIDDLE;
         break;
 
-      case ui::IMEEngineObserver::MOUSE_BUTTON_RIGHT:
+      case InputMethodEngineBase::MOUSE_BUTTON_RIGHT:
         button_enum = input_ime::MOUSE_BUTTON_RIGHT;
         break;
 
-      case ui::IMEEngineObserver::MOUSE_BUTTON_LEFT:
+      case InputMethodEngineBase::MOUSE_BUTTON_LEFT:
       // Default to left.
       default:
         button_enum = input_ime::MOUSE_BUTTON_LEFT;
         break;
     }
 
     scoped_ptr<base::ListValue> args(input_ime::OnCandidateClicked::Create(
         component_id, candidate_id, button_enum));
 
     DispatchEventToExtension(extensions::events::INPUT_IME_ON_CANDIDATE_CLICKED,
@@ skipping 154 matching lines @@
           component.name,
           std::string(),  // TODO(uekawa): Set short name.
           layouts,
           languages,
           false,  // 3rd party IMEs are always not for login.
           component.options_page_url,
           component.input_view_url));
     }
   }
 
-  scoped_ptr<ui::IMEEngineObserver> observer(
+  scoped_ptr<InputMethodEngineBase::Observer> observer(
       new ImeObserverChromeOS(extension_id, profile()));
   chromeos::InputMethodEngine* engine = new chromeos::InputMethodEngine();
   engine->Initialize(std::move(observer), extension_id.c_str(), profile());
   engine_map_[extension_id] = engine;
   chromeos::UserSessionManager::GetInstance()
       ->GetDefaultIMEState(profile())
       ->AddInputMethodExtension(extension_id, descriptors, engine);
 
   return true;
 }
 
 void InputImeEventRouter::UnregisterAllImes(const std::string& extension_id) {
-  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
+  std::map<std::string, InputMethodEngine*>::iterator it =
       engine_map_.find(extension_id);
   if (it != engine_map_.end()) {
     chromeos::input_method::InputMethodManager::Get()
         ->GetActiveIMEState()
         ->RemoveInputMethodExtension(extension_id);
     delete it->second;
     engine_map_.erase(it);
   }
 }
 
-IMEEngineHandlerInterface* InputImeEventRouter::GetEngine(
+InputMethodEngine* InputImeEventRouter::GetEngine(
     const std::string& extension_id,
     const std::string& component_id) {
-  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
+  std::map<std::string, InputMethodEngine*>::iterator it =
       engine_map_.find(extension_id);
   return (it != engine_map_.end()) ? it->second : nullptr;
 }
 
-IMEEngineHandlerInterface* InputImeEventRouter::GetActiveEngine(
+InputMethodEngine* InputImeEventRouter::GetActiveEngine(
     const std::string& extension_id) {
-  std::map<std::string, IMEEngineHandlerInterface*>::iterator it =
+  std::map<std::string, InputMethodEngine*>::iterator it =
       engine_map_.find(extension_id);
   return (it != engine_map_.end() && it->second->IsActive()) ? it->second
                                                              : nullptr;
 }
 
 bool InputImeSetCompositionFunction::RunSync() {
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetComposition::Params> parent_params(
       SetComposition::Params::Create(*args_));
   const SetComposition::Params::Parameters& params = parent_params->parameters;
-  std::vector<IMEEngineHandlerInterface::SegmentInfo> segments;
+  std::vector<InputMethodEngineBase::SegmentInfo> segments;
   if (params.segments) {
     const std::vector<linked_ptr<
         SetComposition::Params::Parameters::SegmentsType> >&
             segments_args = *params.segments;
     for (size_t i = 0; i < segments_args.size(); ++i) {
       EXTENSION_FUNCTION_VALIDATE(
           segments_args[i]->style !=
           input_ime::UNDERLINE_STYLE_NONE);
-      segments.push_back(IMEEngineHandlerInterface::SegmentInfo());
+      segments.push_back(InputMethodEngineBase::SegmentInfo());
       segments.back().start = segments_args[i]->start;
       segments.back().end = segments_args[i]->end;
       if (segments_args[i]->style ==
           input_ime::UNDERLINE_STYLE_UNDERLINE) {
-        segments.back().style =
-            IMEEngineHandlerInterface::SEGMENT_STYLE_UNDERLINE;
+        segments.back().style = InputMethodEngineBase::SEGMENT_STYLE_UNDERLINE;
       } else if (segments_args[i]->style ==
                  input_ime::UNDERLINE_STYLE_DOUBLEUNDERLINE) {
         segments.back().style =
-            IMEEngineHandlerInterface::SEGMENT_STYLE_DOUBLE_UNDERLINE;
+            InputMethodEngineBase::SEGMENT_STYLE_DOUBLE_UNDERLINE;
       } else {
         segments.back().style =
-            IMEEngineHandlerInterface::SEGMENT_STYLE_NO_UNDERLINE;
+            InputMethodEngineBase::SEGMENT_STYLE_NO_UNDERLINE;
       }
     }
   }
 
   int selection_start =
       params.selection_start ? *params.selection_start : params.cursor;
   int selection_end =
       params.selection_end ? *params.selection_end : params.cursor;
 
   SetResult(new base::FundamentalValue(
       engine->SetComposition(params.context_id, params.text.c_str(),
                              selection_start, selection_end, params.cursor,
                              segments, &error_)));
   return true;
 }
 
 bool InputImeClearCompositionFunction::RunSync() {
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<ClearComposition::Params> parent_params(
       ClearComposition::Params::Create(*args_));
   const ClearComposition::Params::Parameters& params =
       parent_params->parameters;
 
   SetResult(new base::FundamentalValue(
       engine->ClearComposition(params.context_id, &error_)));
   return true;
 }
 
 bool InputImeCommitTextFunction::RunSync() {
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<CommitText::Params> parent_params(
       CommitText::Params::Create(*args_));
   const CommitText::Params::Parameters& params =
       parent_params->parameters;
 
   SetResult(new base::FundamentalValue(
       engine->CommitText(params.context_id, params.text.c_str(), &error_)));
   return true;
 }
 
 bool InputImeHideInputViewFunction::RunAsync() {
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     return true;
   }
   engine->HideInputView();
   return true;
 }
 
 bool InputImeSendKeyEventsFunction::RunAsync() {
   scoped_ptr<SendKeyEvents::Params> parent_params(
       SendKeyEvents::Params::Create(*args_));
   const SendKeyEvents::Params::Parameters& params =
       parent_params->parameters;
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::KeyboardEvent> >& key_data =
       params.key_data;
-  std::vector<IMEEngineHandlerInterface::KeyboardEvent> key_data_out;
+  std::vector<InputMethodEngineBase::KeyboardEvent> key_data_out;
 
   for (size_t i = 0; i < key_data.size(); ++i) {
-    IMEEngineHandlerInterface::KeyboardEvent event;
+    InputMethodEngineBase::KeyboardEvent event;
     event.type = input_ime::ToString(key_data[i]->type);
     event.key = key_data[i]->key;
     event.code = key_data[i]->code;
     event.key_code = key_data[i]->key_code.get() ? *(key_data[i]->key_code) : 0;
     if (key_data[i]->alt_key)
       event.alt_key = *(key_data[i]->alt_key);
     if (key_data[i]->ctrl_key)
       event.ctrl_key = *(key_data[i]->ctrl_key);
     if (key_data[i]->shift_key)
       event.shift_key = *(key_data[i]->shift_key);
     if (key_data[i]->caps_lock)
       event.caps_lock = *(key_data[i]->caps_lock);
     key_data_out.push_back(event);
   }
 
   engine->SendKeyEvents(params.context_id, key_data_out);
   return true;
 }
 
 bool InputImeSetCandidateWindowPropertiesFunction::RunSync() {
   scoped_ptr<SetCandidateWindowProperties::Params> parent_params(
       SetCandidateWindowProperties::Params::Create(*args_));
   const SetCandidateWindowProperties::Params::Parameters&
       params = parent_params->parameters;
 
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetEngine(extension_id(), params.engine_id);
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   const SetCandidateWindowProperties::Params::Parameters::Properties&
       properties = params.properties;
 
   if (properties.visible &&
       !engine->SetCandidateWindowVisible(*properties.visible, &error_)) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
-  IMEEngineHandlerInterface::CandidateWindowProperty properties_out =
+  InputMethodEngine::CandidateWindowProperty properties_out =
       engine->GetCandidateWindowProperty();
   bool modified = false;
 
   if (properties.cursor_visible) {
     properties_out.is_cursor_visible = *properties.cursor_visible;
     modified = true;
   }
 
   if (properties.vertical) {
     properties_out.is_vertical = *properties.vertical;
@@ skipping 27 matching lines @@
   if (modified) {
     engine->SetCandidateWindowProperty(properties_out);
   }
 
   SetResult(new base::FundamentalValue(true));
 
   return true;
 }
 
 bool InputImeSetCandidatesFunction::RunSync() {
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetCandidates::Params> parent_params(
       SetCandidates::Params::Create(*args_));
   const SetCandidates::Params::Parameters& params =
       parent_params->parameters;
 
-  std::vector<IMEEngineHandlerInterface::Candidate> candidates_out;
+  std::vector<InputMethodEngine::Candidate> candidates_out;
   const std::vector<linked_ptr<
       SetCandidates::Params::Parameters::CandidatesType> >& candidates_in =
           params.candidates;
   for (size_t i = 0; i < candidates_in.size(); ++i) {
-    candidates_out.push_back(IMEEngineHandlerInterface::Candidate());
+    candidates_out.push_back(InputMethodEngine::Candidate());
     candidates_out.back().value = candidates_in[i]->candidate;
     candidates_out.back().id = candidates_in[i]->id;
     if (candidates_in[i]->label)
       candidates_out.back().label = *candidates_in[i]->label;
     if (candidates_in[i]->annotation)
       candidates_out.back().annotation = *candidates_in[i]->annotation;
     if (candidates_in[i]->usage) {
       candidates_out.back().usage.title = candidates_in[i]->usage->title;
       candidates_out.back().usage.body = candidates_in[i]->usage->body;
     }
   }
 
   SetResult(new base::FundamentalValue(
       engine->SetCandidates(params.context_id, candidates_out, &error_)));
   return true;
 }
 
 bool InputImeSetCursorPositionFunction::RunSync() {
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetCursorPosition::Params> parent_params(
       SetCursorPosition::Params::Create(*args_));
   const SetCursorPosition::Params::Parameters& params =
       parent_params->parameters;
 
   SetResult(new base::FundamentalValue(
       engine->SetCursorPosition(params.context_id, params.candidate_id,
                                 &error_)));
   return true;
 }
 
 bool InputImeSetMenuItemsFunction::RunSync() {
   scoped_ptr<SetMenuItems::Params> parent_params(
       SetMenuItems::Params::Create(*args_));
   const SetMenuItems::Params::Parameters& params =
       parent_params->parameters;
 
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetEngine(extension_id(), params.engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::MenuItem> >& items = params.items;
-  std::vector<IMEEngineHandlerInterface::MenuItem> items_out;
+  std::vector<InputMethodEngine::MenuItem> items_out;
 
   for (size_t i = 0; i < items.size(); ++i) {
-    items_out.push_back(IMEEngineHandlerInterface::MenuItem());
+    items_out.push_back(InputMethodEngine::MenuItem());
     SetMenuItemToMenu(*items[i], &items_out.back());
   }
 
   if (!engine->SetMenuItems(items_out))
     error_ = kErrorSetMenuItemsFail;
   return true;
 }
 
 bool InputImeUpdateMenuItemsFunction::RunSync() {
   scoped_ptr<UpdateMenuItems::Params> parent_params(
       UpdateMenuItems::Params::Create(*args_));
   const UpdateMenuItems::Params::Parameters& params =
       parent_params->parameters;
 
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetEngine(extension_id(), params.engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::MenuItem> >& items = params.items;
-  std::vector<IMEEngineHandlerInterface::MenuItem> items_out;
+  std::vector<InputMethodEngine::MenuItem> items_out;
 
   for (size_t i = 0; i < items.size(); ++i) {
-    items_out.push_back(IMEEngineHandlerInterface::MenuItem());
+    items_out.push_back(InputMethodEngine::MenuItem());
     SetMenuItemToMenu(*items[i], &items_out.back());
   }
 
   if (!engine->UpdateMenuItems(items_out))
     error_ = kErrorUpdateMenuItemsFail;
   return true;
 }
 
 bool InputImeDeleteSurroundingTextFunction::RunSync() {
   scoped_ptr<DeleteSurroundingText::Params> parent_params(
       DeleteSurroundingText::Params::Create(*args_));
   const DeleteSurroundingText::Params::Parameters& params =
       parent_params->parameters;
 
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(Profile::FromBrowserContext(browser_context()))
           ->GetEngine(extension_id(), params.engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   engine->DeleteSurroundingText(params.context_id, params.offset, params.length,
                                 &error_);
   return true;
@@ skipping 15 matching lines @@
       InputComponents::GetInputComponents(extension);
   if (input_components && !input_components->empty()) {
     GetInputImeEventRouter(Profile::FromBrowserContext(browser_context))
         ->UnregisterAllImes(extension->id());
   }
 }
 
 void InputImeAPI::OnListenerAdded(const EventListenerInfo& details) {
   if (!details.browser_context)
     return;
-  IMEEngineHandlerInterface* engine =
+  InputMethodEngine* engine =
       GetInputImeEventRouter(
           Profile::FromBrowserContext(details.browser_context))
           ->GetActiveEngine(details.extension_id);
   // Notifies the IME extension for IME ready with onActivate/onFocus events.
   if (engine)
     engine->Enable(engine->GetActiveComponentId());
 }
 
 }  // namespace extensions