Revert "Move a bunch of ChromeOS APIs out of chrome/browser/extensions."

chrome/browser/extensions/extension_input_ime_api.cc

 // Copyright (c) 2011 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/chromeos/extensions/input_ime_extension_api.h"
+#include "chrome/browser/extensions/extension_input_ime_api.h"
 
 #include "base/json/json_writer.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/extension_event_router.h"
 #include "chrome/browser/extensions/extension_input_module_constants.h"
 #include "chrome/browser/profiles/profile.h"
 
 namespace keys = extension_input_module_constants;
@@ skipping 253 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 =
-        InputImeExtensionEventRouter::GetInstance()->AddRequest(engine_id,
+        ExtensionInputImeEventRouter::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->SetString("keyCode", event.key_code);
     dict->SetBoolean("altKey", event.alt_key);
     dict->SetBoolean("ctrlKey", event.ctrl_key);
     dict->SetBoolean("shiftKey", event.shift_key);
@@ skipping 60 matching lines @@
  private:
   Profile* profile_;
   std::string extension_id_;
   std::string engine_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImeObserver);
 };
 }  // namespace chromeos
 
 
-InputImeExtensionEventRouter*
-InputImeExtensionEventRouter::GetInstance() {
-  return Singleton<InputImeExtensionEventRouter>::get();
+ExtensionInputImeEventRouter*
+ExtensionInputImeEventRouter::GetInstance() {
+  return Singleton<ExtensionInputImeEventRouter>::get();
 }
 
-InputImeExtensionEventRouter::InputImeExtensionEventRouter()
+ExtensionInputImeEventRouter::ExtensionInputImeEventRouter()
   : next_request_id_(1) {
 }
 
-InputImeExtensionEventRouter::~InputImeExtensionEventRouter() {
+ExtensionInputImeEventRouter::~ExtensionInputImeEventRouter() {
 }
 
-void InputImeExtensionEventRouter::Init() {
+void ExtensionInputImeEventRouter::Init() {
 }
 
 #if defined(OS_CHROMEOS)
-bool InputImeExtensionEventRouter::RegisterIme(
+bool ExtensionInputImeEventRouter::RegisterIme(
     Profile* profile,
     const std::string& extension_id,
     const 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 31 matching lines @@
 
   std::map<std::string, chromeos::ImeObserver*>& observer_list =
       observers_[extension_id];
 
   observer_list[component.id] = observer;
 
   return true;
 }
 #endif
 
-chromeos::InputMethodEngine* InputImeExtensionEventRouter::GetEngine(
+chromeos::InputMethodEngine* ExtensionInputImeEventRouter::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* InputImeExtensionEventRouter::GetActiveEngine(
+chromeos::InputMethodEngine* ExtensionInputImeEventRouter::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 InputImeExtensionEventRouter::OnEventHandled(
+void ExtensionInputImeEventRouter::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 InputImeExtensionEventRouter::AddRequest(
+std::string ExtensionInputImeEventRouter::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;
 }
 
 bool SetCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      InputImeExtensionEventRouter::GetInstance()->
+      ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     result_.reset(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
@@ skipping 47 matching lines @@
                              selection_end, segments, &error_)) {
     result_.reset(Value::CreateBooleanValue(true));
   } else {
     result_.reset(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool ClearCompositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      InputImeExtensionEventRouter::GetInstance()->
+      ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     result_.reset(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_)) {
     result_.reset(Value::CreateBooleanValue(true));
   } else {
     result_.reset(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool CommitTextFunction::RunImpl() {
   // TODO(zork): Support committing when not active.
   chromeos::InputMethodEngine* engine =
-      InputImeExtensionEventRouter::GetInstance()->
+      ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     result_.reset(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   std::string text;
@@ skipping 11 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 =
-      InputImeExtensionEventRouter::GetInstance()->GetEngine(extension_id(),
+      ExtensionInputImeEventRouter::GetInstance()->GetEngine(extension_id(),
                                                              engine_id);
   if (!engine) {
     result_.reset(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* properties;
   EXTENSION_FUNCTION_VALIDATE(args->GetDictionary(keys::kPropertiesKey,
                                                   &properties));
 
@@ skipping 90 matching lines @@
         return false;
       }
     }
   }
 
   return true;
 }
 
 bool SetCandidatesFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      InputImeExtensionEventRouter::GetInstance()->
+      ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     result_.reset(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
 
   int context_id;
@@ skipping 14 matching lines @@
   if (engine->SetCandidates(context_id, candidates, &error_)) {
     result_.reset(Value::CreateBooleanValue(true));
   } else {
     result_.reset(Value::CreateBooleanValue(false));
   }
   return true;
 }
 
 bool SetCursorPositionFunction::RunImpl() {
   chromeos::InputMethodEngine* engine =
-      InputImeExtensionEventRouter::GetInstance()->
+      ExtensionInputImeEventRouter::GetInstance()->
           GetActiveEngine(extension_id());
   if (!engine) {
     result_.reset(Value::CreateBooleanValue(false));
     return true;
   }
 
   DictionaryValue* args;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &args));
   int context_id;
   int candidate_id;
@@ skipping 12 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 =
-      InputImeExtensionEventRouter::GetInstance()->GetEngine(extension_id(),
+      ExtensionInputImeEventRouter::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 =
-      InputImeExtensionEventRouter::GetInstance()->GetEngine(extension_id(),
+      ExtensionInputImeEventRouter::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));
 
-  InputImeExtensionEventRouter::GetInstance()->OnEventHandled(
+  ExtensionInputImeEventRouter::GetInstance()->OnEventHandled(
       extension_id(), request_id_str, handled);
 
   return true;
 }
 #endif