Supports multiple profile in Chrome OS IMF.

chrome/browser/chromeos/input_method/input_method_engine.cc

 // Copyright 2013 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/input_method/input_method_engine.h"
 
 #undef FocusIn
 #undef FocusOut
 #undef RootWindow
 #include <map>
 
 #include "ash/shell.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/candidate_window.h"
 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
 #include "ui/base/ime/chromeos/composition_text.h"
 #include "ui/base/ime/chromeos/extension_ime_util.h"
 #include "ui/base/ime/chromeos/ime_keymap.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 #include "ui/base/ime/text_input_flags.h"
 #include "ui/chromeos/ime/input_method_menu_item.h"
@@ skipping 125 matching lines @@
 }  // namespace
 
 InputMethodEngine::InputMethodEngine()
     : current_input_type_(ui::TEXT_INPUT_TYPE_NONE),
       context_id_(0),
       next_context_id_(1),
       composition_text_(new CompositionText()),
       composition_cursor_(0),
       candidate_window_(new ui::CandidateWindow()),
       window_visible_(false),
-      sent_key_event_(NULL) {
+      sent_key_event_(NULL),
+      profile_(NULL) {
 }
 
 InputMethodEngine::~InputMethodEngine() {
 }
 
 void InputMethodEngine::Initialize(
     scoped_ptr<InputMethodEngineInterface::Observer> observer,
-    const char* extension_id) {
+    const char* extension_id,
+    Profile* profile) {
   DCHECK(observer) << "Observer must not be null.";
 
   // TODO(komatsu): It is probably better to set observer out of Initialize.
   observer_ = observer.Pass();
   extension_id_ = extension_id;
+  profile_ = profile;
 }
 
 const std::string& InputMethodEngine::GetActiveComponentId() const {
   return active_component_id_;
 }
 
 bool InputMethodEngine::SetComposition(
     int context_id,
     const char* text,
     int selection_start,
@@ skipping 305 matching lines @@
   keyboard::KeyboardController* keyboard_controller =
     keyboard::KeyboardController::GetInstance();
   if (keyboard_controller) {
     keyboard_controller->HideKeyboard(
         keyboard::KeyboardController::HIDE_REASON_MANUAL);
   }
 }
 
 void InputMethodEngine::SetCompositionBounds(
     const std::vector<gfx::Rect>& bounds) {
+  if (!CheckProfile())

[Alexander Alekseev, 2015/05/13 17:50:38]

This might be tricky, as we've seen delayed events coming after active profile
has been changed. But I do not know what actually observers do, so may be it
doesn't matter.

[Shu Chen, 2015/05/14 04:53:05]

Theoretically CheckProfile() here should always return true. The if-check is for
just-in-case.
And it should have no side effects.

+    return;
   observer_->OnCompositionBoundsChanged(bounds);
 }
 
 void InputMethodEngine::EnableInputView() {
   keyboard::SetOverrideContentUrl(input_method::InputMethodManager::Get()
                                       ->GetActiveIMEState()
                                       ->GetCurrentInputMethod()
                                       .input_view_url());
   keyboard::KeyboardController* keyboard_controller =
       keyboard::KeyboardController::GetInstance();
   if (keyboard_controller)
     keyboard_controller->Reload();
 }
 
 void InputMethodEngine::FocusIn(
     const IMEEngineHandlerInterface::InputContext& input_context) {
+  if (!CheckProfile())
+    return;
   current_input_type_ = input_context.type;
 
   if (!IsActive() || current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   context_id_ = next_context_id_;
   ++next_context_id_;
 
   InputMethodEngineInterface::InputContext context;
   context.id = context_id_;
@@ skipping 25 matching lines @@
       !(input_context.flags & ui::TEXT_INPUT_FLAG_AUTOCORRECT_OFF);
   context.auto_complete =
       !(input_context.flags & ui::TEXT_INPUT_FLAG_AUTOCOMPLETE_OFF);
   context.spell_check =
       !(input_context.flags & ui::TEXT_INPUT_FLAG_SPELLCHECK_OFF);
 
   observer_->OnFocus(context);
 }
 
 void InputMethodEngine::FocusOut() {
+  if (!CheckProfile())
+    return;
   if (!IsActive() || current_input_type_ == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   current_input_type_ = ui::TEXT_INPUT_TYPE_NONE;
 
   int context_id = context_id_;
   context_id_ = -1;
   observer_->OnBlur(context_id);
 }
 
 void InputMethodEngine::Enable(const std::string& component_id) {
+  if (!CheckProfile())
+    return;
   DCHECK(!component_id.empty());
   active_component_id_ = component_id;
   observer_->OnActivate(component_id);
   const IMEEngineHandlerInterface::InputContext& input_context =
       IMEBridge::Get()->GetCurrentInputContext();
   current_input_type_ = input_context.type;
   FocusIn(input_context);
   EnableInputView();
 }
 
 void InputMethodEngine::Disable() {
+  if (!CheckProfile())
+    return;
   active_component_id_.clear();
   observer_->OnDeactivated(active_component_id_);
 }
 
 void InputMethodEngine::PropertyActivate(const std::string& property_name) {
+  if (!CheckProfile())
+    return;
   observer_->OnMenuItemActivated(active_component_id_, property_name);
 }
 
 void InputMethodEngine::Reset() {
+  if (!CheckProfile())
+    return;
   observer_->OnReset(active_component_id_);
 }
 
 bool InputMethodEngine::IsInterestedInKeyEvent() const {
   return observer_->IsInterestedInKeyEvent();
 }
 
 void InputMethodEngine::ProcessKeyEvent(
     const ui::KeyEvent& key_event,
     const KeyEventDoneCallback& callback) {
+  if (!CheckProfile())
+    return;
 
   KeyEventDoneCallback* handler = new KeyEventDoneCallback();
   *handler = callback;
 
   KeyboardEvent ext_event;
   GetExtensionKeyboardEventFromKeyEvent(key_event, &ext_event);
 
   // If the given key event is equal to the key event sent by
   // SendKeyEvents, this engine ID is propagated to the extension IME.
   // Note, this check relies on that ui::KeyEvent is propagated as
   // reference without copying.
   if (&key_event == sent_key_event_)
     ext_event.extension_id = extension_id_;
 
   observer_->OnKeyEvent(
       active_component_id_,
       ext_event,
       reinterpret_cast<input_method::KeyEventHandle*>(handler));
 }
 
 void InputMethodEngine::CandidateClicked(uint32 index) {
+  if (!CheckProfile())
+    return;
   if (index > candidate_ids_.size()) {
     return;
   }
 
   // Only left button click is supported at this moment.
   observer_->OnCandidateClicked(
       active_component_id_, candidate_ids_.at(index), MOUSE_BUTTON_LEFT);
 }
 
 void InputMethodEngine::SetSurroundingText(const std::string& text,
                                            uint32 cursor_pos,
                                            uint32 anchor_pos) {
+  if (!CheckProfile())
+    return;
   observer_->OnSurroundingTextChanged(active_component_id_,
                                       text,
                                       static_cast<int>(cursor_pos),
                                       static_cast<int>(anchor_pos));
 }
 
+bool InputMethodEngine::CheckProfile() const {
+  Profile* active_profile = ProfileManager::GetActiveUserProfile();
+  return active_profile == profile_ || profile_->IsSameProfile(active_profile);
+}
+
 // TODO(uekawa): rename this method to a more reasonable name.
 void InputMethodEngine::MenuItemToProperty(
     const MenuItem& item,
     ui::ime::InputMethodMenuItem* property) {
   property->key = item.id;
 
   if (item.modified & MENU_ITEM_MODIFIED_LABEL) {
     property->label = item.label;
   }
   if (item.modified & MENU_ITEM_MODIFIED_VISIBLE) {
@@ skipping 23 matching lines @@
           // TODO(nona): Implement it.
           break;
       }
     }
   }
 
   // TODO(nona): Support item.children.
 }
 
 }  // namespace chromeos