IME refactoring: ChromeOS introduce input methods State.

chrome/browser/chromeos/input_method/input_method_manager_impl.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/chromeos/input_method/input_method_manager_impl.h"
 
 #include <algorithm>  // std::find
 
+#include <sstream>
+
 #include "ash/ime/input_method_menu_item.h"
 #include "ash/ime/input_method_menu_manager.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 30 matching lines @@
 bool InputMethodManagerImpl::IsLoginKeyboard(
     const std::string& layout) const {
   return util_.IsLoginKeyboard(layout);
 }
 
 bool InputMethodManagerImpl::MigrateInputMethods(
     std::vector<std::string>* input_method_ids) {
   return util_.MigrateInputMethods(input_method_ids);
 }
 
+InputMethodManagerImpl::State::State() {
+}
+
+InputMethodManagerImpl::State::~State() {
+}
+
+void InputMethodManagerImpl::State::InitFrom(const State& other) {
+  // debug_name is not copied.
+
+  previous_input_method_ = other.previous_input_method_;
+  current_input_method_ = other.current_input_method_;
+
+  active_input_method_ids_ = other.active_input_method_ids_;
+
+  saved_previous_input_method_ = other.saved_previous_input_method_;
+  saved_current_input_method_ = other.saved_current_input_method_;
+  saved_active_input_method_ids_ = other.saved_active_input_method_ids_;
+
+  pending_input_method_ = other.pending_input_method_;
+
+  // TODO: recreate all input engines?
+  // typedef std::map<std::string, InputMethodEngineInterface*> EngineMap;
+  engine_map_ = other.engine_map_;
+}
+
+std::string InputMethodManagerImpl::State::Dump() const {
+  std::ostringstream os;
+
+  os << "################# " << state_name << " #################\n";
+
+  os << "previous_input_method_: '"
+     << previous_input_method_.GetPreferredKeyboardLayout() << "'\n";
+  os << "current_input_method_: '"
+     << current_input_method_.GetPreferredKeyboardLayout() << "'\n";
+  os << "active_input_method_ids_ (size=" << active_input_method_ids_.size()
+     << "):";
+  for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
+    os << " '" << active_input_method_ids_[i] << "',";
+  }
+  os << "\n";
+  os << "saved_previous_input_method_: '"
+     << saved_previous_input_method_.GetPreferredKeyboardLayout() << "'\n";
+  os << "saved_current_input_method_: '"
+     << saved_current_input_method_.GetPreferredKeyboardLayout() << "'\n";
+  os << "saved_active_input_method_ids_ (size="
+     << saved_active_input_method_ids_.size() << "):";
+  for (size_t i = 0; i < saved_active_input_method_ids_.size(); ++i) {
+    os << " '" << saved_active_input_method_ids_[i] << "'\n";
+  }
+  os << "pending_input_method_: '" << pending_input_method_ << "'\n";
+  os << "engine_map_ (size=" << engine_map_.size() << "): ...\n ";
+
+  return os.str();
+}
+
+scoped_refptr<InputMethodManager::State> InputMethodManagerImpl::CreateNewState(
+    const std::string& debug_name) const {
+  scoped_refptr<InputMethodManagerImpl::State> new_state(
+      new InputMethodManagerImpl::State);
+  new_state->state_name = debug_name;
+
+  return scoped_refptr<InputMethodManager::State>(new_state.get());
+}
+
+void InputMethodManagerImpl::SetState(

[Shu Chen, 2014/08/04 14:55:23]

I guess this is for fast user switching, correct? I'm concerned that this may
breaks 3rd party IMEs, as enabled_extension_imes_ is not included in State.

I'm not familiar with the design purpose of enabled_extension_imes_. nona@ may
know better.

[Alexander Alekseev, 2014/08/06 23:39:45]

Yes, this was one of my concerns, when I've uploaded this early version of CL. I
also do not understand why enabled_extension_imes_ have always
been shared between users.

[Shu Chen, 2014/08/07 15:40:19]

I think enabled_extension_imes_ should not be shared among users.
Different users may install different 3rd party IME extensions.

[Alexander Alekseev, 2014/08/07 17:26:19]

But it is still shared. (I don't understand why.) So I haven't changed anything
here.

+    scoped_refptr<InputMethodManager::State> state) {
+  LOG(ERROR) << "InputMethodManagerImpl::SetState(): Called.";
+  LOG(ERROR) << "InputMethodManagerImpl::SetState(): old state_: "
+             << (state_ ? state_->Dump() : std::string("NULL"));
+  state_ = static_cast<InputMethodManagerImpl::State*>(state.get());
+  LOG(ERROR) << "InputMethodManagerImpl::SetState(): new state_: "
+             << (state_ ? state_->Dump() : std::string("NULL"));
+  if (state_->active_input_method_ids_.size()) {
+    ReconfigureIMFramework();
+    ChangeInputMethodInternal(state_->current_input_method_, false);

[Shu Chen, 2014/08/04 14:55:23]

Is there particular reason of calling ChangeInputMethodInternal instead of
LookupAndChangeInputMethodInternal?

[Alexander Alekseev, 2014/08/06 23:39:45]

The idea is that SetState should be lightweight, because it is always
consistent. So LookupAndChangeInputMethodInternal() would be doing
extra job of re-checking already consistent configuration.

Also, ReconfigureIMEFramework seems to be too heavy to be re-applied
each time active user is changed. But I haven't yet investigated how
to implement it. Are all users extensions always loaded in multiprofile
mode? If it is so, probably we just need to properly route events to
the current active set. What do you think?

[Shu Chen, 2014/08/07 15:40:19]

I think ReconfigureIMEFramework() is not heavy, because:
LoadNecessaryComponentExtensions() calls
ComponentExtensionIMEManager::LoadComponentExtensionIME() calls
ComponentExtensionIMEManagerImpl::Load() which checks for existing extension:
https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/chr...

There are only 3 component IME extensions, and most of users would only use 1 of
them (XKB extension).
How many calls to GetExtensionById() check depend on how many input methods user
enabled.
But most of users would only enable 1 or 2 input methods.

Have you done a perf profiling to narrow down the real bottle neck?

I'm not familiar with multi-user code, but I have a feeling that when user
switching from A to B, system will unload all extensions of A and install the
extensions of B, which may hurt performance (but that may be a CPU/RAM trade
off).

Can you please briefly introduce how fast user switching works? (or any
documents I get read?)

Thanks

[Alexander Alekseev, 2014/08/07 17:26:18]

Extensions are not unloaded. From the extensions point of view,
multiprofile works just like on a desktop. Each extension is
linked with user Profile, so extensions with the same profile
belong to the same user. They continue to work in background.

We've discussed the performance of LoadNecessaryComponentExtensions() +
FindEngineEntry() off this thread, so I hope you'll look into it ;-)

How User switching worked for IMs before your refactoring:

Method chromeos::Preferences::ActiveUserChanged() is called on each
user switch. (Just before it is called, GetActiveUser() starts returning
new active user). It invokes chromeos::Preferences::ApplyPrefes(), which
reinitializes IME settings according to the user profile. (And it is relatively
slow, because converting user settings to IME configuration
takes time). So that, when IME methods are called (like ChangeInputMethod()),
GetActiveUserProfile() already returns new user profile. It means that all
static data in IME is shared between users.
The only exception was the list of extensions which was per-user.

As far as I understand your previous refactoring of IME, you've left
all shared data shared, but moved GetActiveUserProfile() to
ComponentExtensionsIMEManagerImpl. It is definitely better than the
previous code, because you reduced the number of calls to
GetActiveUserProfile().

On the other hand, what I am trying to achieve: I'll put Profile* to
IME::State, so that GetActiveUser would be never needed in IME.

I think, I'll upload a new version soon.

+  }
+}
+
 InputMethodManagerImpl::InputMethodManagerImpl(
     scoped_ptr<InputMethodDelegate> delegate)
     : delegate_(delegate.Pass()),
-      state_(STATE_LOGIN_SCREEN),
+      ui_state_(STATE_LOGIN_SCREEN),
       util_(delegate_.get(), whitelist_.GetSupportedInputMethods()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
       weak_ptr_factory_(this) {
+  SetState(CreateNewState("default"));
 }
 
 InputMethodManagerImpl::~InputMethodManagerImpl() {
   if (candidate_window_controller_.get())
     candidate_window_controller_->RemoveObserver(this);
 }
 
 void InputMethodManagerImpl::AddObserver(
     InputMethodManager::Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void InputMethodManagerImpl::AddCandidateWindowObserver(
     InputMethodManager::CandidateWindowObserver* observer) {
   candidate_window_observers_.AddObserver(observer);
 }
 
 void InputMethodManagerImpl::RemoveObserver(
     InputMethodManager::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void InputMethodManagerImpl::RemoveCandidateWindowObserver(
     InputMethodManager::CandidateWindowObserver* observer) {
   candidate_window_observers_.RemoveObserver(observer);
 }
 
-void InputMethodManagerImpl::SetState(State new_state) {
-  const State old_state = state_;
-  state_ = new_state;
-  switch (state_) {
+void InputMethodManagerImpl::SetUIState(UIState new_ui_state) {
+  const UIState old_ui_state = ui_state_;
+  ui_state_ = new_ui_state;
+  switch (ui_state_) {
     case STATE_LOGIN_SCREEN:
       break;
     case STATE_BROWSER_SCREEN:
-      if (old_state == STATE_LOCK_SCREEN)
+      if (old_ui_state == STATE_LOCK_SCREEN)
         OnScreenUnlocked();
       break;
     case STATE_LOCK_SCREEN:
       OnScreenLocked();
       break;
     case STATE_TERMINATING: {
       if (candidate_window_controller_.get())
         candidate_window_controller_.reset();
       break;
     }
   }
 }
 
 scoped_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetSupportedInputMethods() const {
   if (!IsXkbComponentExtensionAvailable())
     return whitelist_.GetSupportedInputMethods().Pass();
   return scoped_ptr<InputMethodDescriptors>(new InputMethodDescriptors).Pass();
 }
 
 scoped_ptr<InputMethodDescriptors>
 InputMethodManagerImpl::GetActiveInputMethods() const {
   scoped_ptr<InputMethodDescriptors> result(new InputMethodDescriptors);
   // Build the active input method descriptors from the active input
   // methods cache |active_input_method_ids_|.
-  for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
-    const std::string& input_method_id = active_input_method_ids_[i];
+  DCHECK(state_);
+  for (size_t i = 0; i < state_->active_input_method_ids_.size(); ++i) {
+    const std::string& input_method_id = state_->active_input_method_ids_[i];
     const InputMethodDescriptor* descriptor =
         util_.GetInputMethodDescriptorFromId(input_method_id);
     if (descriptor) {
       result->push_back(*descriptor);
     } else {
       std::map<std::string, InputMethodDescriptor>::const_iterator ix =
           extra_input_methods_.find(input_method_id);
       if (ix != extra_input_methods_.end())
         result->push_back(ix->second);
       else
         DVLOG(1) << "Descriptor is not found for: " << input_method_id;
     }
   }
   if (result->empty()) {
     // Initially |active_input_method_ids_| is empty. browser_tests might take
     // this path.
     result->push_back(
         InputMethodUtil::GetFallbackInputMethodDescriptor());
   }
   return result.Pass();
 }
 
 const std::vector<std::string>&
 InputMethodManagerImpl::GetActiveInputMethodIds() const {
-  return active_input_method_ids_;
+  DCHECK(state_);
+  return state_->active_input_method_ids_;
 }
 
 size_t InputMethodManagerImpl::GetNumActiveInputMethods() const {
-  return active_input_method_ids_.size();
+  DCHECK(state_);
+  return state_->active_input_method_ids_.size();
 }
 
 const InputMethodDescriptor* InputMethodManagerImpl::GetInputMethodFromId(
     const std::string& input_method_id) const {
   const InputMethodDescriptor* ime = util_.GetInputMethodDescriptorFromId(
       input_method_id);
   if (!ime) {
     std::map<std::string, InputMethodDescriptor>::const_iterator ix =
         extra_input_methods_.find(input_method_id);
     if (ix != extra_input_methods_.end())
       ime = &ix->second;
   }
   return ime;
 }
 
 void InputMethodManagerImpl::EnableLoginLayouts(
     const std::string& language_code,
     const std::vector<std::string>& initial_layouts) {
-  if (state_ == STATE_TERMINATING)
+  if (ui_state_ == STATE_TERMINATING)
     return;
+  LOG(ERROR) << "InputMethodManagerImpl::EnableLoginLayouts(): old state_: "
+             << state_->Dump();
 
   // First, hardware keyboard layout should be shown.
   std::vector<std::string> candidates =
       util_.GetHardwareLoginInputMethodIds();
 
   // Seocnd, locale based input method should be shown.
   // Add input methods associated with the language.
   std::vector<std::string> layouts_from_locale;
   util_.GetInputMethodIdsFromLanguageCode(language_code,
                                           kKeyboardLayoutsOnly,
@@ skipping 23 matching lines @@
   // Add candidates to layouts, while skipping duplicates.
   for (size_t i = 0; i < candidates.size(); ++i) {
     const std::string& candidate = candidates[i];
     // Not efficient, but should be fine, as the two vectors are very
     // short (2-5 items).
     if (!Contains(layouts, candidate) && IsLoginKeyboard(candidate))
       layouts.push_back(candidate);
   }
 
   MigrateInputMethods(&layouts);
-  active_input_method_ids_.swap(layouts);
+  DCHECK(state_);
+  state_->active_input_method_ids_.swap(layouts);
+  LOG(ERROR) << "InputMethodManagerImpl::EnableLoginLayouts(): new state_: "
+             << state_->Dump();
 
   // Initialize candidate window controller and widgets such as
   // candidate window, infolist and mode indicator.  Note, mode
   // indicator is used by only keyboard layout input methods.
-  if (active_input_method_ids_.size() > 1)
+  if (state_->active_input_method_ids_.size() > 1)
     MaybeInitializeCandidateWindowController();
 
   // you can pass empty |initial_layout|.
   ChangeInputMethod(initial_layouts.empty() ? "" :
       extension_ime_util::GetInputMethodIDByEngineID(initial_layouts[0]));
 }
 
 // Adds new input method to given list.
 bool InputMethodManagerImpl::EnableInputMethodImpl(
     const std::string& input_method_id,
@@ skipping 15 matching lines @@
   LoadNecessaryComponentExtensions();
 
   // Initialize candidate window controller and widgets such as
   // candidate window, infolist and mode indicator.  Note, mode
   // indicator is used by only keyboard layout input methods.
   MaybeInitializeCandidateWindowController();
 }
 
 bool InputMethodManagerImpl::EnableInputMethod(
     const std::string& input_method_id) {
-  if (!EnableInputMethodImpl(input_method_id, &active_input_method_ids_))
+  DCHECK(state_);
+  if (!EnableInputMethodImpl(input_method_id,
+                             &(state_->active_input_method_ids_)))
     return false;
 
   ReconfigureIMFramework();
   return true;
 }
 
 bool InputMethodManagerImpl::ReplaceEnabledInputMethods(
     const std::vector<std::string>& new_active_input_method_ids) {
-  if (state_ == STATE_TERMINATING)
+  if (ui_state_ == STATE_TERMINATING)
     return false;
+  LOG(ERROR)
+      << "InputMethodManagerImpl::ReplaceEnabledInputMethods(): old state_: "
+      << state_->Dump();
 
   // Filter unknown or obsolete IDs.
   std::vector<std::string> new_active_input_method_ids_filtered;
 
   for (size_t i = 0; i < new_active_input_method_ids.size(); ++i)
     EnableInputMethodImpl(new_active_input_method_ids[i],
                           &new_active_input_method_ids_filtered);
 
   if (new_active_input_method_ids_filtered.empty()) {
     DVLOG(1) << "ReplaceEnabledInputMethods: No valid input method ID";
     return false;
   }
 
   // Copy extension IDs to |new_active_input_method_ids_filtered|. We have to
   // keep relative order of the extension input method IDs.
-  for (size_t i = 0; i < active_input_method_ids_.size(); ++i) {
-    const std::string& input_method_id = active_input_method_ids_[i];
+  DCHECK(state_);
+  for (size_t i = 0; i < state_->active_input_method_ids_.size(); ++i) {
+    const std::string& input_method_id = state_->active_input_method_ids_[i];
     if (extension_ime_util::IsExtensionIME(input_method_id))
       new_active_input_method_ids_filtered.push_back(input_method_id);
   }
-  active_input_method_ids_.swap(new_active_input_method_ids_filtered);
-  MigrateInputMethods(&active_input_method_ids_);
+  state_->active_input_method_ids_.swap(new_active_input_method_ids_filtered);
+  MigrateInputMethods(&(state_->active_input_method_ids_));
 
+  LOG(ERROR)
+      << "InputMethodManagerImpl::ReplaceEnabledInputMethods(): new state_: "
+      << state_->Dump();
   ReconfigureIMFramework();
 
   // If |current_input_method| is no longer in |active_input_method_ids_|,
   // ChangeInputMethod() picks the first one in |active_input_method_ids_|.
-  ChangeInputMethod(current_input_method_.id());
+  ChangeInputMethod(state_->current_input_method_.id());
   return true;
 }
 
 void InputMethodManagerImpl::ChangeInputMethod(
     const std::string& input_method_id) {
-  ChangeInputMethodInternal(input_method_id, false);
+  LookupAndChangeInputMethodInternal(input_method_id, false);
 }
 
-bool InputMethodManagerImpl::ChangeInputMethodInternal(
+void InputMethodManagerImpl::ChangeInputMethodInternal(
+    const InputMethodDescriptor& descriptor,
+    bool show_message) {
+  // Change the keyboard layout to a preferred layout for the input method.
+  if (!keyboard_->SetCurrentKeyboardLayoutByName(
+          descriptor.GetPreferredKeyboardLayout())) {
+    LOG(ERROR) << "Failed to change keyboard layout to "
+               << descriptor.GetPreferredKeyboardLayout();
+  }
+
+  // Update input method indicators (e.g. "US", "DV") in Chrome windows.
+  FOR_EACH_OBSERVER(InputMethodManager::Observer,
+                    observers_,
+                    InputMethodChanged(this, show_message));
+}
+
+bool InputMethodManagerImpl::LookupAndChangeInputMethodInternal(

[Shu Chen, 2014/08/04 14:55:23]

looks like the bool return value never gets used.

[Alexander Alekseev, 2014/08/06 23:39:45]

Done.

     const std::string& input_method_id,
     bool show_message) {
-  if (state_ == STATE_TERMINATING)
+  if (ui_state_ == STATE_TERMINATING)
     return false;
 
   std::string input_method_id_to_switch = input_method_id;
 
   // Sanity check.
   if (!InputMethodIsActivated(input_method_id)) {
     scoped_ptr<InputMethodDescriptors> input_methods(GetActiveInputMethods());
     DCHECK(!input_methods->empty());
     input_method_id_to_switch = input_methods->at(0).id();
     if (!input_method_id.empty()) {
       DVLOG(1) << "Can't change the current input method to "
                << input_method_id << " since the engine is not enabled. "
                << "Switch to " << input_method_id_to_switch << " instead.";
     }
   }
 
   if (!component_extension_ime_manager_->IsInitialized() &&
       !InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch)) {
     // We can't change input method before the initialization of
     // component extension ime manager.  ChangeInputMethod will be
     // called with |pending_input_method_| when the initialization is
     // done.
-    pending_input_method_ = input_method_id_to_switch;
+    state_->pending_input_method_ = input_method_id_to_switch;
     return false;
   }
-  pending_input_method_.clear();
+  state_->pending_input_method_.clear();
 
   // Hide candidate window and info list.
   if (candidate_window_controller_.get())
     candidate_window_controller_->Hide();
 
   // Disable the current engine handler.
   IMEEngineHandlerInterface* engine =
       IMEBridge::Get()->GetCurrentEngineHandler();
   if (engine)
     engine->Disable();
 
   // Configure the next engine handler.
   if (InputMethodUtil::IsKeyboardLayout(input_method_id_to_switch) &&
       !extension_ime_util::IsKeyboardLayoutExtension(
           input_method_id_to_switch)) {
     IMEBridge::Get()->SetCurrentEngineHandler(NULL);
   } else {
     IMEEngineHandlerInterface* next_engine =
-        profile_engine_map_[GetProfile()][input_method_id_to_switch];
+        state_->engine_map_[input_method_id_to_switch];
     if (next_engine) {
       IMEBridge::Get()->SetCurrentEngineHandler(next_engine);
       next_engine->Enable();
     }
   }
 
   // TODO(komatsu): Check if it is necessary to perform the above routine
   // when the current input method is equal to |input_method_id_to_swich|.
-  if (current_input_method_.id() != input_method_id_to_switch) {
+  if (state_->current_input_method_.id() != input_method_id_to_switch) {
     // Clear property list.  Property list would be updated by
     // extension IMEs via InputMethodEngine::(Set|Update)MenuItems.
     // If the current input method is a keyboard layout, empty
     // properties are sufficient.
     const ash::ime::InputMethodMenuItemList empty_menu_item_list;
     ash::ime::InputMethodMenuManager* input_method_menu_manager =
         ash::ime::InputMethodMenuManager::GetInstance();
     input_method_menu_manager->SetCurrentInputMethodMenuItemList(
             empty_menu_item_list);
 
     const InputMethodDescriptor* descriptor = NULL;
     if (extension_ime_util::IsExtensionIME(input_method_id_to_switch)) {
       DCHECK(extra_input_methods_.find(input_method_id_to_switch) !=
              extra_input_methods_.end());
       descriptor = &(extra_input_methods_[input_method_id_to_switch]);
     } else {
       descriptor =
           util_.GetInputMethodDescriptorFromId(input_method_id_to_switch);
       if (!descriptor)
         LOG(ERROR) << "Unknown input method id: " << input_method_id_to_switch;
     }
     DCHECK(descriptor);
 
-    previous_input_method_ = current_input_method_;
-    current_input_method_ = *descriptor;
+    state_->previous_input_method_ = state_->current_input_method_;
+    state_->current_input_method_ = *descriptor;
   }
 
-  // Change the keyboard layout to a preferred layout for the input method.
-  if (!keyboard_->SetCurrentKeyboardLayoutByName(
-          current_input_method_.GetPreferredKeyboardLayout())) {
-    LOG(ERROR) << "Failed to change keyboard layout to "
-               << current_input_method_.GetPreferredKeyboardLayout();
-  }
-
-  // Update input method indicators (e.g. "US", "DV") in Chrome windows.
-  FOR_EACH_OBSERVER(InputMethodManager::Observer,
-                    observers_,
-                    InputMethodChanged(this, show_message));
+  ChangeInputMethodInternal(state_->current_input_method_, show_message);
   return true;
 }
 
 bool InputMethodManagerImpl::IsXkbComponentExtensionAvailable() const {
   if (!component_extension_ime_manager_->IsInitialized())
     return false;
   InputMethodDescriptors imes =
       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
   for (size_t i = 0; i < imes.size(); ++i) {
     if (StartsWithASCII(extension_ime_util::MaybeGetLegacyXkbId(
@@ skipping 11 matching lines @@
       component_extension_ime_manager_->GetAllIMEAsInputMethodDescriptor();
   // In case of XKB extension is not available (e.g. linux_chromeos), don't
   // reset the input methods in InputMethodUtil, Instead append input methods.
   if (IsXkbComponentExtensionAvailable())
     util_.ResetInputMethods(imes);
   else
     util_.AppendInputMethods(imes);
 
   LoadNecessaryComponentExtensions();
 
-  if (!pending_input_method_.empty())
-    ChangeInputMethodInternal(pending_input_method_, false);
+  DCHECK(state_);
+  if (!state_->pending_input_method_.empty())
+    LookupAndChangeInputMethodInternal(state_->pending_input_method_, false);
 }
 
 void InputMethodManagerImpl::LoadNecessaryComponentExtensions() {
   if (!component_extension_ime_manager_->IsInitialized())
     return;
+  LOG(ERROR) << "InputMethodManagerImpl::LoadNecessaryComponentExtensions(): "
+                "old state_: " << state_->Dump();
   // Load component extensions but also update |active_input_method_ids_| as
   // some component extension IMEs may have been removed from the Chrome OS
   // image. If specified component extension IME no longer exists, falling back
   // to an existing IME.
+  DCHECK(state_);
   std::vector<std::string> unfiltered_input_method_ids;
-  unfiltered_input_method_ids.swap(active_input_method_ids_);
+  unfiltered_input_method_ids.swap(state_->active_input_method_ids_);
   for (size_t i = 0; i < unfiltered_input_method_ids.size(); ++i) {
     if (!extension_ime_util::IsComponentExtensionIME(
         unfiltered_input_method_ids[i])) {
       // Legacy IMEs or xkb layouts are alwayes active.
-      active_input_method_ids_.push_back(unfiltered_input_method_ids[i]);
+      state_->active_input_method_ids_.push_back(
+          unfiltered_input_method_ids[i]);
     } else if (component_extension_ime_manager_->IsWhitelisted(
         unfiltered_input_method_ids[i])) {
       component_extension_ime_manager_->LoadComponentExtensionIME(
           unfiltered_input_method_ids[i]);
-      active_input_method_ids_.push_back(unfiltered_input_method_ids[i]);
+      state_->active_input_method_ids_.push_back(
+          unfiltered_input_method_ids[i]);
     }
   }
+  LOG(ERROR) << "InputMethodManagerImpl::LoadNecessaryComponentExtensions(): "
+                "new state_: " << state_->Dump();
   // TODO(shuchen): move this call in ComponentExtensionIMEManager.
   component_extension_ime_manager_->NotifyInitialized();
 }
 
 void InputMethodManagerImpl::ActivateInputMethodMenuItem(
     const std::string& key) {
   DCHECK(!key.empty());
 
   if (ash::ime::InputMethodMenuManager::GetInstance()->
       HasInputMethodMenuItemForKey(key)) {
     IMEEngineHandlerInterface* engine =
         IMEBridge::Get()->GetCurrentEngineHandler();
     if (engine)
       engine->PropertyActivate(key);
     return;
   }
 
   DVLOG(1) << "ActivateInputMethodMenuItem: unknown key: " << key;
 }
 
 void InputMethodManagerImpl::AddInputMethodExtension(
     const std::string& id,
     InputMethodEngineInterface* engine) {
-  if (state_ == STATE_TERMINATING)
+  if (ui_state_ == STATE_TERMINATING)
     return;
+  LOG(ERROR)
+      << "InputMethodManagerImpl::AddInputMethodExtension(): old state_: "
+      << state_->Dump();
 
   DCHECK(engine);
+  DCHECK(state_);
 
-  profile_engine_map_[GetProfile()][id] = engine;
+  state_->engine_map_[id] = engine;

[Shu Chen, 2014/08/04 14:55:23]

I think this will break something. GetProfile() is necessary to match profile
map in InputMethodEventRouter.
If you want to remove the profiled map here, you have to remove the profiled map
in InputMethodEventRouter.
And that would be an even bigger change. Please refer to cl:
https://codereview.chromium.org/433163005/.

So, this flow will be broken, if only removing profiled map in
InputMethodManagerImpl.
Engine contains Observer which contains profile which is used to dispatch events
to extension.
Suppose there are 2 users: A and B, and they both use input method X.
InputMethodManagerImpl::AddInputMethodExtension() will be called for both A and
B.
 - AddInputMethodExtension(<engineX with observer to IME extension loaded under
user A>)
 - AddInputMethodExtension(<engineX with observer to IME extension loaded under
user B>)
Now <engineX with observer to IME extension loaded under user B> will overwrite
<engineX with observer to IME extension loaded under user A> in
state_->engine_map_.
So under user A, InputMethodManagerImpl::ChangeInputMethod() cannot successfully
send onActivate event to IME extension because the engine it can get is for user
B. And user B's IME extension will get onActivate unexpectedly.

[Alexander Alekseev, 2014/08/06 23:39:45]

state_ is per-user, so this would never happen.

I'm going to remove profile map in Router also. The idea is that
Router should route events according to current IME state.
I haven't done it because I do not know why enabled_input_methods_
is shared.

 
-  if (id == current_input_method_.id()) {
+  if (id == state_->current_input_method_.id()) {
     IMEBridge::Get()->SetCurrentEngineHandler(engine);
     engine->Enable();
   }
 
   if (extension_ime_util::IsComponentExtensionIME(id))
     return;
 
   CHECK(extension_ime_util::IsExtensionIME(id))
       << id << "is not a valid extension input method ID";
 
   const InputMethodDescriptor& descriptor = engine->GetDescriptor();
   extra_input_methods_[id] = descriptor;
 
   if (Contains(enabled_extension_imes_, id)) {
-    if (!Contains(active_input_method_ids_, id)) {
-      active_input_method_ids_.push_back(id);
+    if (!Contains(state_->active_input_method_ids_, id)) {
+      state_->active_input_method_ids_.push_back(id);
+      LOG(ERROR)
+          << "InputMethodManagerImpl::AddInputMethodExtension(): new state_: "
+          << state_->Dump();
     } else {
       DVLOG(1) << "AddInputMethodExtension: alread added: "
                << id << ", " << descriptor.name();
     }
 
     // Ensure that the input method daemon is running.
     MaybeInitializeCandidateWindowController();
   }
 }
 
 void InputMethodManagerImpl::RemoveInputMethodExtension(const std::string& id) {
   if (!extension_ime_util::IsExtensionIME(id))
     DVLOG(1) << id << " is not a valid extension input method ID.";
+  LOG(ERROR) << "InputMethodManagerImpl::RemoveInputMethodExtension('" << id
+             << "'): old state_: " << state_->Dump();
 
-  std::vector<std::string>::iterator i = std::find(
-      active_input_method_ids_.begin(), active_input_method_ids_.end(), id);
-  if (i != active_input_method_ids_.end())
-    active_input_method_ids_.erase(i);
+  DCHECK(state_);
+  std::vector<std::string>::iterator i =
+      std::find(state_->active_input_method_ids_.begin(),
+                state_->active_input_method_ids_.end(),
+                id);
+  if (i != state_->active_input_method_ids_.end())
+    state_->active_input_method_ids_.erase(i);
   extra_input_methods_.erase(id);
 
-  EngineMap& engine_map = profile_engine_map_[GetProfile()];
-  if (IMEBridge::Get()->GetCurrentEngineHandler() == engine_map[id])
+  if (IMEBridge::Get()->GetCurrentEngineHandler() == state_->engine_map_[id])
     IMEBridge::Get()->SetCurrentEngineHandler(NULL);
-  engine_map.erase(id);
+  state_->engine_map_.erase(id);
+  LOG(ERROR) << "InputMethodManagerImpl::RemoveInputMethodExtension('" << id
+             << "'): new state_: " << state_->Dump();
 
   // No need to switch input method when terminating.
-  if (state_ != STATE_TERMINATING) {
+  if (ui_state_ != STATE_TERMINATING) {
     // If |current_input_method| is no longer in |active_input_method_ids_|,
     // switch to the first one in |active_input_method_ids_|.
-    ChangeInputMethod(current_input_method_.id());
+    ChangeInputMethod(state_->current_input_method_.id());
   }
 }
 
 void InputMethodManagerImpl::GetInputMethodExtensions(
     InputMethodDescriptors* result) {
   // Build the extension input method descriptors from the extra input
   // methods cache |extra_input_methods_|.
   std::map<std::string, InputMethodDescriptor>::iterator iter;
   for (iter = extra_input_methods_.begin(); iter != extra_input_methods_.end();
        ++iter) {
     if (extension_ime_util::IsExtensionIME(iter->first))
       result->push_back(iter->second);
   }
 }
 
 void InputMethodManagerImpl::SetEnabledExtensionImes(
     std::vector<std::string>* ids) {
   enabled_extension_imes_.clear();
   enabled_extension_imes_.insert(enabled_extension_imes_.end(),
                                  ids->begin(),
                                  ids->end());
+  LOG(ERROR)
+      << "InputMethodManagerImpl::SetEnabledExtensionImes(): old state_: "
+      << state_->Dump();
 
   bool active_imes_changed = false;
 
   for (std::map<std::string, InputMethodDescriptor>::iterator extra_iter =
        extra_input_methods_.begin(); extra_iter != extra_input_methods_.end();
        ++extra_iter) {
     if (extension_ime_util::IsComponentExtensionIME(
         extra_iter->first))
       continue;  // Do not filter component extension.
-    std::vector<std::string>::iterator active_iter = std::find(
-        active_input_method_ids_.begin(), active_input_method_ids_.end(),
-        extra_iter->first);
+    DCHECK(state_);
+    std::vector<std::string>::iterator active_iter =
+        std::find(state_->active_input_method_ids_.begin(),
+                  state_->active_input_method_ids_.end(),
+                  extra_iter->first);
 
-    bool active = active_iter != active_input_method_ids_.end();
+    bool active = active_iter != state_->active_input_method_ids_.end();
     bool enabled = Contains(enabled_extension_imes_, extra_iter->first);
 
     if (active && !enabled)
-      active_input_method_ids_.erase(active_iter);
+      state_->active_input_method_ids_.erase(active_iter);
 
     if (!active && enabled)
-      active_input_method_ids_.push_back(extra_iter->first);
+      state_->active_input_method_ids_.push_back(extra_iter->first);
 
     if (active == !enabled)
       active_imes_changed = true;
   }
+  LOG(ERROR)
+      << "InputMethodManagerImpl::SetEnabledExtensionImes(): new state_: "
+      << state_->Dump();
 
   if (active_imes_changed) {
     MaybeInitializeCandidateWindowController();
 
     // If |current_input_method| is no longer in |active_input_method_ids_|,
     // switch to the first one in |active_input_method_ids_|.
-    ChangeInputMethod(current_input_method_.id());
+    ChangeInputMethod(state_->current_input_method_.id());
   }
 }
 
 void InputMethodManagerImpl::SetInputMethodLoginDefaultFromVPD(
     const std::string& locale, const std::string& oem_layout) {
   std::string layout;
   if (!oem_layout.empty()) {
     // If the OEM layout information is provided, use it.
     layout = oem_layout;
   } else {
@@ skipping 46 matching lines @@
       // If kPreferredKeyboardLayout is not specified, use the hardware layout.
       input_methods_to_be_enabled = util_.GetHardwareLoginInputMethodIds();
     } else {
       input_methods_to_be_enabled.push_back(initial_input_method_id);
     }
     EnableLoginLayouts(locale, input_methods_to_be_enabled);
   }
 }
 
 bool InputMethodManagerImpl::SwitchToNextInputMethod() {
+  DCHECK(state_);
   // Sanity checks.
-  if (active_input_method_ids_.empty()) {
+  if (state_->active_input_method_ids_.empty()) {
     DVLOG(1) << "active input method is empty";
     return false;
   }
 
-  if (current_input_method_.id().empty()) {
+  if (state_->current_input_method_.id().empty()) {
     DVLOG(1) << "current_input_method_ is unknown";
     return false;
   }
 
   // Do not consume key event if there is only one input method is enabled.
   // Ctrl+Space or Alt+Shift may be used by other application.
-  if (active_input_method_ids_.size() == 1)
+  if (state_->active_input_method_ids_.size() == 1)
     return false;
 
   // Find the next input method and switch to it.
-  SwitchToNextInputMethodInternal(active_input_method_ids_,
-                                  current_input_method_.id());
+  SwitchToNextInputMethodInternal(state_->active_input_method_ids_,
+                                  state_->current_input_method_.id());
   return true;
 }
 
 bool InputMethodManagerImpl::SwitchToPreviousInputMethod(
     const ui::Accelerator& accelerator) {
+  DCHECK(state_);
   // Sanity check.
-  if (active_input_method_ids_.empty()) {
+  if (state_->active_input_method_ids_.empty()) {
     DVLOG(1) << "active input method is empty";
     return false;
   }
 
   // Do not consume key event if there is only one input method is enabled.
   // Ctrl+Space or Alt+Shift may be used by other application.
-  if (active_input_method_ids_.size() == 1)
+  if (state_->active_input_method_ids_.size() == 1)
     return false;
 
   if (accelerator.type() == ui::ET_KEY_RELEASED)
     return true;
 
-  if (previous_input_method_.id().empty() ||
-      previous_input_method_.id() == current_input_method_.id()) {
+  if (state_->previous_input_method_.id().empty() ||
+      state_->previous_input_method_.id() ==
+          state_->current_input_method_.id()) {
     return SwitchToNextInputMethod();
   }
 
   std::vector<std::string>::const_iterator iter =
-      std::find(active_input_method_ids_.begin(),
-                active_input_method_ids_.end(),
-                previous_input_method_.id());
-  if (iter == active_input_method_ids_.end()) {
+      std::find(state_->active_input_method_ids_.begin(),
+                state_->active_input_method_ids_.end(),
+                state_->previous_input_method_.id());
+  if (iter == state_->active_input_method_ids_.end()) {
     // previous_input_method_ is not supported.
     return SwitchToNextInputMethod();
   }
-  ChangeInputMethodInternal(*iter, true);
+  LookupAndChangeInputMethodInternal(*iter, true);
   return true;
 }
 
 bool InputMethodManagerImpl::SwitchInputMethod(
     const ui::Accelerator& accelerator) {
+  DCHECK(state_);
   // Sanity check.
-  if (active_input_method_ids_.empty()) {
+  if (state_->active_input_method_ids_.empty()) {
     DVLOG(1) << "active input method is empty";
     return false;
   }
 
   // Get the list of input method ids for the |accelerator|. For example, get
   // { "mozc-hangul", "xkb:kr:kr104:kor" } for ui::VKEY_DBE_SBCSCHAR.
   std::vector<std::string> input_method_ids_to_switch;
   switch (accelerator.key_code()) {
     case ui::VKEY_CONVERT:  // Henkan key on JP106 keyboard
       input_method_ids_to_switch.push_back(
@@ skipping 18 matching lines @@
     DVLOG(1) << "Unexpected VKEY: " << accelerator.key_code();
     return false;
   }
 
   // Obtain the intersection of input_method_ids_to_switch and
   // active_input_method_ids_. The order of IDs in active_input_method_ids_ is
   // preserved.
   std::vector<std::string> ids;
   for (size_t i = 0; i < input_method_ids_to_switch.size(); ++i) {
     const std::string& id = input_method_ids_to_switch[i];
-    if (Contains(active_input_method_ids_, id))
+    if (Contains(state_->active_input_method_ids_, id))
       ids.push_back(id);
   }
   if (ids.empty()) {
     // No input method for the accelerator is active. For example, we should
     // just ignore VKEY_HANGUL when mozc-hangul is not active.
     return false;
   }
 
-  SwitchToNextInputMethodInternal(ids, current_input_method_.id());
+  SwitchToNextInputMethodInternal(ids, state_->current_input_method_.id());
   return true;  // consume the accelerator.
 }
 
 void InputMethodManagerImpl::SwitchToNextInputMethodInternal(
     const std::vector<std::string>& input_method_ids,
     const std::string& current_input_method_id) {
   std::vector<std::string>::const_iterator iter =
       std::find(input_method_ids.begin(),
                 input_method_ids.end(),
                 current_input_method_id);
   if (iter != input_method_ids.end())
     ++iter;
   if (iter == input_method_ids.end())
     iter = input_method_ids.begin();
-  ChangeInputMethodInternal(*iter, true);
+  LookupAndChangeInputMethodInternal(*iter, true);
 }
 
 InputMethodDescriptor InputMethodManagerImpl::GetCurrentInputMethod() const {
-  if (current_input_method_.id().empty())
+  DCHECK(state_);
+  if (state_->current_input_method_.id().empty())
     return InputMethodUtil::GetFallbackInputMethodDescriptor();
 
-  return current_input_method_;
+  return state_->current_input_method_;
 }
 
 bool InputMethodManagerImpl::IsISOLevel5ShiftUsedByCurrentInputMethod() const {
   return keyboard_->IsISOLevel5ShiftAvailable();
 }
 
 bool InputMethodManagerImpl::IsAltGrUsedByCurrentInputMethod() const {
   return keyboard_->IsAltGrAvailable();
 }
 
@@ skipping 65 matching lines @@
                     CandidateWindowOpened(this));
 }
 
 void InputMethodManagerImpl::CandidateWindowClosed() {
   FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
                     candidate_window_observers_,
                     CandidateWindowClosed(this));
 }
 
 void InputMethodManagerImpl::OnScreenLocked() {
-  saved_previous_input_method_ = previous_input_method_;
-  saved_current_input_method_ = current_input_method_;
-  saved_active_input_method_ids_ = active_input_method_ids_;
+  DCHECK(state_);
+  LOG(ERROR) << "InputMethodManagerImpl::OnScreenLocked(): old state_: "
+             << state_->Dump();
+  state_->saved_previous_input_method_ = state_->previous_input_method_;
+  state_->saved_current_input_method_ = state_->current_input_method_;
+  state_->saved_active_input_method_ids_ = state_->active_input_method_ids_;
 
   std::set<std::string> added_ids_;
 
   const std::vector<std::string>& hardware_keyboard_ids =
       util_.GetHardwareLoginInputMethodIds();
 
-  active_input_method_ids_.clear();
-  for (size_t i = 0; i < saved_active_input_method_ids_.size(); ++i) {
-    const std::string& input_method_id = saved_active_input_method_ids_[i];
+  state_->active_input_method_ids_.clear();
+  for (size_t i = 0; i < state_->saved_active_input_method_ids_.size(); ++i) {
+    const std::string& input_method_id =
+        state_->saved_active_input_method_ids_[i];
     // Skip if it's not a keyboard layout. Drop input methods including
     // extension ones.
     if (!IsLoginKeyboard(input_method_id) ||
         added_ids_.find(input_method_id) != added_ids_.end())
       continue;
-    active_input_method_ids_.push_back(input_method_id);
+    state_->active_input_method_ids_.push_back(input_method_id);
     added_ids_.insert(input_method_id);
   }
 
   // We'll add the hardware keyboard if it's not included in
   // |active_input_method_ids_| so that the user can always use the hardware
   // keyboard on the screen locker.
   for (size_t i = 0; i < hardware_keyboard_ids.size(); ++i) {
     if (added_ids_.find(hardware_keyboard_ids[i]) == added_ids_.end()) {
-      active_input_method_ids_.push_back(hardware_keyboard_ids[i]);
+      state_->active_input_method_ids_.push_back(hardware_keyboard_ids[i]);
       added_ids_.insert(hardware_keyboard_ids[i]);
     }
   }
 
-  ChangeInputMethod(current_input_method_.id());
+  LOG(ERROR) << "InputMethodManagerImpl::OnScreenLocked(): new state_: "
+             << state_->Dump();
+  ChangeInputMethod(state_->current_input_method_.id());
 }
 
 void InputMethodManagerImpl::OnScreenUnlocked() {
-  previous_input_method_ = saved_previous_input_method_;
-  current_input_method_ = saved_current_input_method_;
-  active_input_method_ids_ = saved_active_input_method_ids_;
+  LOG(ERROR) << "InputMethodManagerImpl::OnScreenUnLocked(): old state_: "
+             << state_->Dump();
+  state_->previous_input_method_ = state_->saved_previous_input_method_;
+  state_->current_input_method_ = state_->saved_current_input_method_;
+  state_->active_input_method_ids_ = state_->saved_active_input_method_ids_;
 
-  ChangeInputMethod(current_input_method_.id());
+  LOG(ERROR) << "InputMethodManagerImpl::OnScreenUnLocked(): new state_: "
+             << state_->Dump();
+  ChangeInputMethod(state_->current_input_method_.id());
 }
 
 bool InputMethodManagerImpl::InputMethodIsActivated(
     const std::string& input_method_id) {
-  return Contains(active_input_method_ids_, input_method_id);
+  DCHECK(state_);
+  return Contains(state_->active_input_method_ids_, input_method_id);
 }
 
 void InputMethodManagerImpl::MaybeInitializeCandidateWindowController() {
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
-Profile* InputMethodManagerImpl::GetProfile() const {
-  return ProfileManager::GetActiveUserProfile();
-}
-
 }  // namespace input_method
 }  // namespace chromeos