Keeps the opt-in IME menu in lock screen.

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 <stdint.h>
 
 #include <algorithm>  // std::find
 #include <memory>
@@ skipping 94 matching lines @@
     *first_char = ch;
   return category;
 }
 
 }  // namespace
 
 // ------------------------ InputMethodManagerImpl::StateImpl
 
 InputMethodManagerImpl::StateImpl::StateImpl(InputMethodManagerImpl* manager,
                                              Profile* profile)
-    : profile(profile), manager_(manager) {
-}
+    : profile(profile), manager_(manager), menu_activated(false) {}
 
 InputMethodManagerImpl::StateImpl::~StateImpl() {
 }
 
 void InputMethodManagerImpl::StateImpl::InitFrom(const StateImpl& other) {
   previous_input_method = other.previous_input_method;
   current_input_method = other.current_input_method;
 
   active_input_method_ids = other.active_input_method_ids;
 
   pending_input_method_id = other.pending_input_method_id;
 
   enabled_extension_imes = other.enabled_extension_imes;
   extra_input_methods = other.extra_input_methods;
+  menu_activated = other.menu_activated;
 }
 
 bool InputMethodManagerImpl::StateImpl::IsActive() const {
   return manager_->state_.get() == this;
 }
 
 std::string InputMethodManagerImpl::StateImpl::Dump() const {
   std::ostringstream os;
 
   os << "################# "
@@ skipping 708 matching lines @@
 
 InputMethodManagerImpl::InputMethodManagerImpl(
     std::unique_ptr<InputMethodDelegate> delegate,
     bool enable_extension_loading)
     : delegate_(std::move(delegate)),
       ui_session_(STATE_LOGIN_SCREEN),
       state_(NULL),
       util_(delegate_.get()),
       component_extension_ime_manager_(new ComponentExtensionIMEManager()),
       enable_extension_loading_(enable_extension_loading),
-      is_ime_menu_activated_(false) {
+      menu_activated_(false) {
   // TODO(mohsen): Revisit using FakeImeKeyboard with mash when InputController
   // work is ready. http://crbug.com/601981
   if (base::SysInfo::IsRunningOnChromeOS() && !chrome::IsRunningInMash())
     keyboard_.reset(ImeKeyboard::Create());
   else
     keyboard_.reset(new FakeImeKeyboard());
 
   // Initializes the system IME list.
   std::unique_ptr<ComponentExtensionIMEManagerDelegate> comp_delegate(
       new ComponentExtensionIMEManagerImpl());
@@ skipping 50 matching lines @@
 }
 
 InputMethodManager::UISessionState InputMethodManagerImpl::GetUISessionState() {
   return ui_session_;
 }
 
 void InputMethodManagerImpl::SetUISessionState(UISessionState new_ui_session) {
   ui_session_ = new_ui_session;
   if (ui_session_ == STATE_TERMINATING && candidate_window_controller_.get())
     candidate_window_controller_.reset();
-
-  // The expanded IME menu is only supportive with 'normal' screen type. It
-  // should be deactivated when the screen type is not 'normal', and be
-  // re-activated when changing back.
-  if (is_ime_menu_activated_ && ui_session_ != STATE_TERMINATING) {
-    FOR_EACH_OBSERVER(
-        InputMethodManager::ImeMenuObserver, ime_menu_observers_,
-        ImeMenuActivationChanged(ui_session_ == STATE_BROWSER_SCREEN));
-  }
 }
 
 void InputMethodManagerImpl::OnUserAddingStarted() {
   if (ui_session_ == STATE_BROWSER_SCREEN)
     SetUISessionState(STATE_SECONDARY_LOGIN_SCREEN);
 }
 
 void InputMethodManagerImpl::OnUserAddingFinished() {
   if (ui_session_ == STATE_SECONDARY_LOGIN_SCREEN)
     SetUISessionState(STATE_BROWSER_SCREEN);
@@ skipping 229 matching lines @@
 }
 
 void InputMethodManagerImpl::CandidateWindowClosed() {
   FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
                     candidate_window_observers_,
                     CandidateWindowClosed(this));
 }
 
 void InputMethodManagerImpl::ImeMenuActivationChanged(bool is_active) {
   // Saves the state that whether the expanded IME menu has been activated by
-  // users. This method is only called when the preference is changing.
-  is_ime_menu_activated_ = is_active;
+  // users. This method is only called when the preference is changing or the
+  // active user changed.

[Shu Chen, 2016/08/29 08:20:08]

revert this comment change.

[Azure Wei, 2016/08/29 08:27:47]

Done.

+  menu_activated_ = is_active;
+  state_->menu_activated = menu_activated_;
   FOR_EACH_OBSERVER(InputMethodManager::ImeMenuObserver, ime_menu_observers_,
-                    ImeMenuActivationChanged(is_active));
+                    ImeMenuActivationChanged(menu_activated_));
   UMA_HISTOGRAM_BOOLEAN("InputMethod.ImeMenu.ActivationChanged",
-                        is_ime_menu_activated_);
+                        menu_activated_);

[Shu Chen, 2016/08/29 08:20:08]

void InputMethodManagerImpl::ImeMenuActivationChanged(bool is_active) {
  state_->menu_activated = menu_activated_;
  MaybeNotifyImeMenuActivationChanged();
}

void InputMethodManagerImpl::MaybeNotifyImeMenuActivationChanged() {
  if (menu_activated_ == state_->menu_activated)
    return;
  menu_activated_ = state_->menu_activated;
  FOR_EACH_OBSERVER(InputMethodManager::ImeMenuObserver, ime_menu_observers_,
      ImeMenuActivationChanged(menu_activated_));
  UMA_HISTOGRAM_BOOLEAN("InputMethod.ImeMenu.ActivationChanged",
      menu_activated_);
}

[Azure Wei, 2016/08/29 08:27:47]

Done.

 }
 
 void InputMethodManagerImpl::NotifyImeMenuListChanged() {
   FOR_EACH_OBSERVER(InputMethodManager::ImeMenuObserver, ime_menu_observers_,
                     ImeMenuListChanged());
 }
 
 void InputMethodManagerImpl::MaybeInitializeCandidateWindowController() {
   if (candidate_window_controller_.get())
     return;
 
   candidate_window_controller_.reset(
       CandidateWindowController::CreateCandidateWindowController());
   candidate_window_controller_->AddObserver(this);
 }
 
 void InputMethodManagerImpl::NotifyImeMenuItemsChanged(
     const std::string& engine_id,
     const std::vector<InputMethodManager::MenuItem>& items) {
   FOR_EACH_OBSERVER(InputMethodManager::ImeMenuObserver, ime_menu_observers_,
                     ImeMenuItemsChanged(engine_id, items));
 }
 
+void InputMethodManagerImpl::MaybeNotifyImeMenuActivationChanged() {
+  bool is_active = state_->menu_activated;
+  if (menu_activated_ != is_active) {
+    ImeMenuActivationChanged(is_active);
+  }
+}
+
 }  // namespace input_method
 }  // namespace chromeos