ozone: Protect X11-specific code in IME support

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 "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/chromeos/input_method/input_method_engine.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/input_ime.h"
 #include "chrome/common/extensions/api/input_ime/input_components_handler.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function_registry.h"
 #include "extensions/browser/extension_system.h"
 
+#if defined(USE_X11)
+#include "chrome/browser/chromeos/input_method/input_method_engine.h"
+#endif
+
 namespace input_ime = extensions::api::input_ime;
 namespace KeyEventHandled = extensions::api::input_ime::KeyEventHandled;
 namespace DeleteSurroundingText =
     extensions::api::input_ime::DeleteSurroundingText;
 namespace UpdateMenuItems = extensions::api::input_ime::UpdateMenuItems;
 namespace SendKeyEvents = extensions::api::input_ime::SendKeyEvents;
 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;
@@ skipping 269 matching lines @@
 
 }  // namespace chromeos
 
 namespace extensions {
 
 InputImeEventRouter*
 InputImeEventRouter::GetInstance() {
   return Singleton<InputImeEventRouter>::get();
 }
 
-#if defined(OS_CHROMEOS)
 bool InputImeEventRouter::RegisterIme(
     Profile* profile,
     const std::string& extension_id,
     const extensions::InputComponentInfo& component) {
+#if defined(USE_X11)
   VLOG(1) << "RegisterIme: " << extension_id << " id: " << component.id;
 
   // If the engine exists already, it may be registered with an old profile.
   // So overwrite it with the new engine instance.
   EngineMap& engine_map = engines_[extension_id];
   EngineMap::iterator engine_ix = engine_map.find(component.id);
   if (engine_ix != engine_map.end()) {
     delete engine_ix->second;
     engine_map.erase(engine_ix);
   }
@@ skipping 16 matching lines @@
                      component.name.c_str(),
                      extension_id.c_str(),
                      component.id.c_str(),
                      languages,
                      layouts,
                      component.options_page_url,
                      component.input_view_url);
   engine_map[component.id] = engine;
 
   return true;
+#else
+  // TODO(spang): IME support under ozone.
+  NOTIMPLEMENTED();
+  return false;
+#endif
 }
 
 void InputImeEventRouter::UnregisterAllImes(
     Profile* profile, const std::string& extension_id) {
   std::map<std::string, EngineMap>::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);
   }
 }
-#endif
 
 InputMethodEngineInterface* InputImeEventRouter::GetEngine(
     const std::string& extension_id, const std::string& engine_id) {
   std::map<std::string,
            std::map<std::string, InputMethodEngineInterface*> >::const_iterator
                engine_list = engines_.find(extension_id);
   if (engine_list != engines_.end()) {
     std::map<std::string, InputMethodEngineInterface*>::const_iterator
         engine_ix = engine_list->second.find(engine_id);
     if (engine_ix != engine_list->second.end())
@@ skipping 160 matching lines @@
       parent_params->parameters;
   chromeos::InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     error_ = kErrorEngineNotAvailable;
     return false;
   }
 
   const std::vector<linked_ptr<input_ime::KeyboardEvent> >& key_data =
       params.key_data;
-  std::vector<chromeos::InputMethodEngine::KeyboardEvent> key_data_out;
+  std::vector<chromeos::InputMethodEngineInterface::KeyboardEvent> key_data_out;
 
   for (size_t i = 0; i < key_data.size(); ++i) {
-    chromeos::InputMethodEngine::KeyboardEvent event;
+    chromeos::InputMethodEngineInterface::KeyboardEvent event;
     event.type = input_ime::KeyboardEvent::ToString(key_data[i]->type);
     event.key = key_data[i]->key;
     event.code = key_data[i]->code;
     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)
@@ skipping 73 matching lines @@
 
   if (modified) {
     engine->SetCandidateWindowProperty(properties_out);
   }
 
   SetResult(new base::FundamentalValue(true));
 
   return true;
 }
 
-#if defined(OS_CHROMEOS)
 bool InputImeSetCandidatesFunction::RunImpl() {
   InputMethodEngineInterface* engine =
       InputImeEventRouter::GetInstance()->GetActiveEngine(extension_id());
   if (!engine) {
     SetResult(new base::FundamentalValue(false));
     return true;
   }
 
   scoped_ptr<SetCandidates::Params> parent_params(
       SetCandidates::Params::Create(*args_));
@@ skipping 115 matching lines @@
   return true;
 }
 
 bool InputImeKeyEventHandledFunction::RunImpl() {
   scoped_ptr<KeyEventHandled::Params> params(
       KeyEventHandled::Params::Create(*args_));
   InputImeEventRouter::GetInstance()->OnKeyEventHandled(
       extension_id(), params->request_id, params->response);
   return true;
 }
-#endif
 
 InputImeAPI::InputImeAPI(content::BrowserContext* context)
     : profile_(Profile::FromBrowserContext(context)) {
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_LOADED,
                  content::Source<Profile>(profile_));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                  content::Source<Profile>(profile_));
 
@@ skipping 49 matching lines @@
       input_ime_event_router()->GetActiveEngine(details.extension_id);
   if (engine)
     engine->NotifyImeReady();
 }
 
 InputImeEventRouter* InputImeAPI::input_ime_event_router() {
   return InputImeEventRouter::GetInstance();
 }
 
 }  // namespace extensions