Moving input_ime to api/ .

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/extension_input_ime_api.h"
+#include "chrome/browser/extensions/api/input_ime/input_ime_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_input_module_constants.h"
 #include "chrome/browser/profiles/profile.h"
 
@@ skipping 210 matching lines @@
         GURL());
   }
 
   virtual void OnKeyEvent(const std::string& engine_id,
                           const InputMethodEngine::KeyboardEvent& event,
                           chromeos::input_method::KeyEventHandle* key_data) {
     if (profile_ == NULL || extension_id_.empty())
       return;
 
     std::string request_id =
-        ExtensionInputImeEventRouter::GetInstance()->AddRequest(engine_id,
-                                                                key_data);
+        extensions::InputImeEventRouter::GetInstance()->AddRequest(engine_id,
+                                                                   key_data);
 
     DictionaryValue* dict = new DictionaryValue();
     dict->SetString("type", event.type);
     dict->SetString("requestId", request_id);
     dict->SetString("key", event.key);
     dict->SetBoolean("altKey", event.alt_key);
     dict->SetBoolean("ctrlKey", event.ctrl_key);
     dict->SetBoolean("shiftKey", event.shift_key);
 
     ListValue args;
@@ skipping 58 matching lines @@
  private:
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserver);
 };
 
 }  // namespace chromeos
 
-ExtensionInputImeEventRouter*
-ExtensionInputImeEventRouter::GetInstance() {
-  return Singleton<ExtensionInputImeEventRouter>::get();
+namespace extensions {
+
+InputImeEventRouter*
+InputImeEventRouter::GetInstance() {
+  return Singleton<InputImeEventRouter>::get();
 }
 
-void ExtensionInputImeEventRouter::Init() {}
+void InputImeEventRouter::Init() {}
 
 #if defined(OS_CHROMEOS)
-bool ExtensionInputImeEventRouter::RegisterIme(
+bool InputImeEventRouter::RegisterIme(
     Profile* profile,
     const std::string& extension_id,
     const extensions::Extension::InputComponentInfo& component) {
   VLOG(1) << "RegisterIme: " << extension_id << " id: " << component.id;
 
   std::map<std::string, chromeos::InputMethodEngine*>& engine_map =
       engines_[extension_id];
 
   std::map<std::string, chromeos::InputMethodEngine*>::iterator engine_ix =
       engine_map.find(component.id);
@@ skipping 22 matching lines @@
   engine_map[component.id] = engine;
 
   std::map<std::string, chromeos::ImeObserver*>& observer_list =
       observers_[extension_id];
 
   observer_list[component.id] = observer;
 
   return true;
 }
 
-void ExtensionInputImeEventRouter::UnregisterAllImes(
+void InputImeEventRouter::UnregisterAllImes(
     Profile* profile, const std::string& extension_id) {
   std::map<std::string,
            std::map<std::string,
                     chromeos::InputMethodEngine*> >::iterator engine_map =
       engines_.find(extension_id);
   if (engine_map != engines_.end()) {
     STLDeleteContainerPairSecondPointers(engine_map->second.begin(),
                                          engine_map->second.end());
     engines_.erase(engine_map);
   }
 
   std::map<std::string,
            std::map<std::string,
                     chromeos::ImeObserver*> >::iterator observer_list =
       observers_.find(extension_id);
   if (observer_list != observers_.end()) {
     STLDeleteContainerPairSecondPointers(observer_list->second.begin(),
                                          observer_list->second.end());
     observers_.erase(observer_list);
   }
 }
 #endif
 
-chromeos::InputMethodEngine* ExtensionInputImeEventRouter::GetEngine(
+chromeos::InputMethodEngine* InputImeEventRouter::GetEngine(
     const std::string& extension_id, const std::string& engine_id) {
   std::map<std::string,
            std::map<std::string, chromeos::InputMethodEngine*> >::const_iterator
                engine_list = engines_.find(extension_id);
   if (engine_list != engines_.end()) {
     std::map<std::string, chromeos::InputMethodEngine*>::const_iterator
         engine_ix = engine_list->second.find(engine_id);
     if (engine_ix != engine_list->second.end()) {
       return engine_ix->second;
     }
   }
   return NULL;
 }
 
-chromeos::InputMethodEngine* ExtensionInputImeEventRouter::GetActiveEngine(
+chromeos::InputMethodEngine* InputImeEventRouter::GetActiveEngine(
     const std::string& extension_id) {
   std::map<std::string,
            std::map<std::string, chromeos::InputMethodEngine*> >::const_iterator
                engine_list = engines_.find(extension_id);
   if (engine_list != engines_.end()) {
     std::map<std::string, chromeos::InputMethodEngine*>::const_iterator
         engine_ix;
     for (engine_ix = engine_list->second.begin();
          engine_ix != engine_list->second.end();
          ++engine_ix) {
       if (engine_ix->second->IsActive()) {
         return engine_ix->second;
       }
     }
   }
   return NULL;
 }
 
-void ExtensionInputImeEventRouter::OnEventHandled(
+void InputImeEventRouter::OnEventHandled(
     const std::string& extension_id,
     const std::string& request_id,
     bool handled) {
   RequestMap::iterator request = request_map_.find(request_id);
   if (request == request_map_.end()) {
     LOG(ERROR) << "Request ID not found: " << request_id;
     return;
   }
 
   std::string engine_id = request->second.first;
   chromeos::input_method::KeyEventHandle* key_data = request->second.second;
   request_map_.erase(request);
 
   chromeos::InputMethodEngine* engine = GetEngine(extension_id, engine_id);
   if (!engine) {
     LOG(ERROR) << "Engine does not exist: " << engine_id;
     return;
   }
 
   engine->KeyEventDone(key_data, handled);
 }
 
-std::string ExtensionInputImeEventRouter::AddRequest(
+std::string InputImeEventRouter::AddRequest(
     const std::string& engine_id,
     chromeos::input_method::KeyEventHandle* key_data) {
   std::string request_id = base::IntToString(next_request_id_);
   ++next_request_id_;
 
   request_map_[request_id] = std::make_pair(engine_id, key_data);
 
   return request_id;
 }
 
-ExtensionInputImeEventRouter::ExtensionInputImeEventRouter()
+InputImeEventRouter::InputImeEventRouter()
   : next_request_id_(1) {
 }
 
-ExtensionInputImeEventRouter::~ExtensionInputImeEventRouter() {}
+InputImeEventRouter::~InputImeEventRouter() {}
 
 bool SetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->
-          GetActiveEngine(extension_id());
+      InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
   int selection_start;
@@ skipping 54 matching lines @@
                              selection_end, cursor, segments, &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool ClearCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->
-          GetActiveEngine(extension_id());
+      InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
 
   EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kContextIdKey,
                                                &context_id));
 
   if (engine->ClearComposition(context_id, &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool CommitTextFunction::RunImpl() {
   // TODO(zork): Support committing when not active.
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->
-          GetActiveEngine(extension_id());
+      InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
 
@@ skipping 10 matching lines @@
 }
 
 bool SetCandidateWindowPropertiesFunction::RunImpl() {
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->GetEngine(extension_id(),
-                                                             engine_id);
+      InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* properties;
   EXTENSION_FUNCTION_VALIDATE(args->GetDictionary(keys::kPropertiesKey,
                                                   &properties));
 
   if (properties->HasKey(keys::kVisibleKey)) {
@@ skipping 89 matching lines @@
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool SetCandidatesFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->
-          GetActiveEngine(extension_id());
+      InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   int context_id;
   std::vector<chromeos::InputMethodEngine::Candidate> candidates;
@@ skipping 13 matching lines @@
   if (engine->SetCandidates(context_id, candidates, &error_)) {
     SetResult(Value::CreateBooleanValue(true));
   } else {
     SetResult(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetCursorPositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->
-          GetActiveEngine(extension_id());
+      InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   int candidate_id;
 
@@ skipping 11 matching lines @@
 }
 
 bool SetMenuItemsFunction::RunImpl() {
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->GetEngine(extension_id(),
-                                                             engine_id);
+      InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   ListValue* items;
   EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kItemsKey, &items));
 
   std::vector<chromeos::InputMethodEngine::MenuItem> menu_items;
   EXTENSION_FUNCTION_VALIDATE(ReadMenuItems(items, &menu_items));
 
   if (!engine->SetMenuItems(menu_items)) {
     error_ = kErrorSetMenuItemsFail;
   }
   return true;
 }
 
 bool UpdateMenuItemsFunction::RunImpl() {
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   std::string engine_id;
   EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kEngineIdKey, &engine_id));
 
   chromeos::InputMethodEngine* engine =
-      ExtensionInputImeEventRouter::GetInstance()->GetEngine(extension_id(),
-                                                             engine_id);
+      InputImeEventRouter::GetInstance()->GetEngine(extension_id(), engine_id);
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   ListValue* items;
   EXTENSION_FUNCTION_VALIDATE(args->GetList(keys::kItemsKey, &items));
 
   std::vector<chromeos::InputMethodEngine::MenuItem> menu_items;
   EXTENSION_FUNCTION_VALIDATE(ReadMenuItems(items, &menu_items));
 
   if (!engine->UpdateMenuItems(menu_items)) {
     error_ = kErrorUpdateMenuItemsFail;
   }
   return true;
 }
 
 bool InputEventHandled::RunImpl() {
   std::string request_id_str;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &request_id_str));
 
   bool handled = false;
   EXTENSION_FUNCTION_VALIDATE(args_->GetBoolean(1, &handled));
 
-  ExtensionInputImeEventRouter::GetInstance()->OnEventHandled(
+  InputImeEventRouter::GetInstance()->OnEventHandled(
       extension_id(), request_id_str, handled);
 
   return true;
 }
 #endif
+
+}  // namespace extensions