IME refactoring: ChromeOS introduce input methods State.

chrome/browser/chromeos/input_method/input_method_manager_impl.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_MANAGER_IMPL_H_
 #define CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_MANAGER_IMPL_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 12 matching lines @@
 class ComponentExtensionIMEManagerDelegate;
 class InputMethodEngine;
 namespace input_method {
 class InputMethodDelegate;
 class ImeKeyboard;
 
 // The implementation of InputMethodManager.
 class InputMethodManagerImpl : public InputMethodManager,
                                public CandidateWindowController::Observer {
  public:
+  class State : public InputMethodManager::State {

[Nikita (slow), 2014/08/13 10:56:41]

As discussed, makes sense to rename as StateImpl.

[Alexander Alekseev, 2014/08/13 23:29:32]

Done.

+   public:
+    State(InputMethodManagerImpl* manager, Profile* profile);
+
+    // Init new state as a copy of other.
+    void InitFrom(const State& other);
+
+    // Returns true if (manager_->state_ == this).
+    bool IsActive() const;
+
+    // Returns human-readable dump (for debug).
+    std::string Dump() const;
+
+    // Adds new input method to given list if possible
+    bool EnableInputMethodImpl(
+        const std::string& input_method_id,
+        std::vector<std::string>* new_active_input_method_ids) const;
+
+    // Returns true if |input_method_id| is in |active_input_method_ids|.
+    bool InputMethodIsActivated(const std::string& input_method_id);
+
+    // If |current_input_methodid_| is not in |input_method_ids|, switch to
+    // input_method_ids[0]. If the ID is equal to input_method_ids[N], switch to
+    // input_method_ids[N+1].
+    void SwitchToNextInputMethodInternal(
+        const std::vector<std::string>& input_method_ids,
+        const std::string& current_input_methodid);
+
+    // InputMethodManager::State overrides.
+    virtual void AddInputMethodExtension(
+        const std::string& extension_id,
+        const InputMethodDescriptors& descriptors,
+        InputMethodEngineInterface* instance) OVERRIDE;
+    virtual void RemoveInputMethodExtension(
+        const std::string& extension_id) OVERRIDE;
+    virtual void ChangeInputMethod(const std::string& input_method_id,
+                                   bool show_message) OVERRIDE;
+    virtual bool EnableInputMethod(
+        const std::string& new_active_input_method_id) OVERRIDE;
+    virtual void EnableLoginLayouts(
+        const std::string& language_code,
+        const std::vector<std::string>& initial_layouts) OVERRIDE;
+    virtual void EnableLockScreenLayouts() OVERRIDE;
+    virtual void GetInputMethodExtensions(
+        InputMethodDescriptors* result) OVERRIDE;
+    virtual scoped_ptr<InputMethodDescriptors> GetActiveInputMethods()
+        const OVERRIDE;
+    virtual const std::vector<std::string>& GetActiveInputMethodIds()
+        const OVERRIDE;
+    virtual const InputMethodDescriptor* GetInputMethodFromId(
+        const std::string& input_method_id) const OVERRIDE;
+    virtual size_t GetNumActiveInputMethods() const OVERRIDE;
+    virtual void SetEnabledExtensionImes(
+        std::vector<std::string>* ids) OVERRIDE;
+    virtual void SetInputMethodLoginDefault() OVERRIDE;
+    virtual void SetInputMethodLoginDefaultFromVPD(
+        const std::string& locale,
+        const std::string& layout) OVERRIDE;
+    virtual bool SwitchToNextInputMethod() OVERRIDE;
+    virtual bool SwitchToPreviousInputMethod(
+        const ui::Accelerator& accelerator) OVERRIDE;
+    virtual bool SwitchInputMethod(const ui::Accelerator& accelerator) OVERRIDE;
+    virtual InputMethodDescriptor GetCurrentInputMethod() const OVERRIDE;
+    virtual bool ReplaceEnabledInputMethods(
+        const std::vector<std::string>& new_active_input_method_ids) OVERRIDE;
+
+    // ------------------------- Data members.
+    Profile* const profile;
+
+    // The input method which was/is selected.
+    InputMethodDescriptor previous_input_method;
+    InputMethodDescriptor current_input_method;
+
+    // The active input method ids cache.
+    std::vector<std::string> active_input_method_ids;
+
+    // The list of enabled extension IMEs.
+    std::vector<std::string> enabled_extension_imes;
+
+    // Extra input methods that have been explicitly added to the menu, such as
+    // those created by extension.
+    std::map<std::string, InputMethodDescriptor> extra_input_methods;
+
+   private:
+    InputMethodManagerImpl* const manager_;
+
+   protected:
+    friend base::RefCounted<chromeos::input_method::InputMethodManager::State>;
+    virtual ~State();
+  };
+
   // Constructs an InputMethodManager instance. The client is responsible for
-  // calling |SetState| in response to relevant changes in browser state.
+  // calling |SetUISessionState| in response to relevant changes in browser
+  // state.
   explicit InputMethodManagerImpl(scoped_ptr<InputMethodDelegate> delegate);
   virtual ~InputMethodManagerImpl();
 
-  // Receives notification of an InputMethodManager::State transition.
-  void SetState(State new_state);
+  // Receives notification of an InputMethodManager::UISessionState transition.
+  void SetUISessionState(UISessionState new_ui_session);
 
   // InputMethodManager override:
-  virtual void InitializeComponentExtension() OVERRIDE;
+  virtual void InitializeComponentExtension(Profile* profile) OVERRIDE;
   virtual void AddObserver(InputMethodManager::Observer* observer) OVERRIDE;
   virtual void AddCandidateWindowObserver(
       InputMethodManager::CandidateWindowObserver* observer) OVERRIDE;
   virtual void RemoveObserver(InputMethodManager::Observer* observer) OVERRIDE;
   virtual void RemoveCandidateWindowObserver(
       InputMethodManager::CandidateWindowObserver* observer) OVERRIDE;
   virtual scoped_ptr<InputMethodDescriptors>
       GetSupportedInputMethods() const OVERRIDE;
-  virtual scoped_ptr<InputMethodDescriptors>
-      GetActiveInputMethods() const OVERRIDE;
-  virtual const std::vector<std::string>& GetActiveInputMethodIds() const
-      OVERRIDE;
-  virtual size_t GetNumActiveInputMethods() const OVERRIDE;
-  virtual const InputMethodDescriptor* GetInputMethodFromId(
-      const std::string& input_method_id) const OVERRIDE;
-  virtual void EnableLoginLayouts(
-      const std::string& language_code,
-      const std::vector<std::string>& initial_layouts) OVERRIDE;
-  virtual bool ReplaceEnabledInputMethods(
-      const std::vector<std::string>& new_active_input_method_ids) OVERRIDE;
-  virtual bool EnableInputMethod(const std::string& new_active_input_method_id)
-      OVERRIDE;
-  virtual void ChangeInputMethod(const std::string& input_method_id) OVERRIDE;
   virtual void ActivateInputMethodMenuItem(const std::string& key) OVERRIDE;
-  virtual void AddInputMethodExtension(
-      const std::string& extension_id,
-      const InputMethodDescriptors& descriptors,
-      InputMethodEngineInterface* instance) OVERRIDE;
-  virtual void RemoveInputMethodExtension(
-      const std::string& extension_id) OVERRIDE;
-  virtual void GetInputMethodExtensions(
-      InputMethodDescriptors* result) OVERRIDE;
-  virtual void SetEnabledExtensionImes(std::vector<std::string>* ids) OVERRIDE;
-  virtual void SetInputMethodLoginDefault() OVERRIDE;
-  virtual void SetInputMethodLoginDefaultFromVPD(
-      const std::string& locale, const std::string& layout) OVERRIDE;
-  virtual bool SwitchToNextInputMethod() OVERRIDE;
-  virtual bool SwitchToPreviousInputMethod(
-      const ui::Accelerator& accelerator) OVERRIDE;
-  virtual bool SwitchInputMethod(const ui::Accelerator& accelerator) OVERRIDE;
-  virtual InputMethodDescriptor GetCurrentInputMethod() const OVERRIDE;
   virtual bool IsISOLevel5ShiftUsedByCurrentInputMethod() const OVERRIDE;
   virtual bool IsAltGrUsedByCurrentInputMethod() const OVERRIDE;
 
   virtual ImeKeyboard* GetImeKeyboard() OVERRIDE;
   virtual InputMethodUtil* GetInputMethodUtil() OVERRIDE;
   virtual ComponentExtensionIMEManager*
       GetComponentExtensionIMEManager() OVERRIDE;
   virtual bool IsLoginKeyboard(const std::string& layout) const OVERRIDE;
 
   virtual bool MigrateInputMethods(
       std::vector<std::string>* input_method_ids) OVERRIDE;
 
+  virtual scoped_refptr<InputMethodManager::State> GetDefaultState(
+      Profile* profile) OVERRIDE;
+
+  virtual scoped_refptr<InputMethodManager::State> GetActiveIMEState() OVERRIDE;
+  virtual scoped_refptr<InputMethodManager::State> CloneState(
+      const InputMethodManager::State* state) OVERRIDE;
+  virtual void SetState(
+      scoped_refptr<InputMethodManager::State> state) OVERRIDE;
+
   // Sets |candidate_window_controller_|.
   void SetCandidateWindowControllerForTesting(
       CandidateWindowController* candidate_window_controller);
   // Sets |keyboard_|.
   void SetImeKeyboardForTesting(ImeKeyboard* keyboard);
   // Initialize |component_extension_manager_|.
   void InitializeComponentExtensionForTesting(
       scoped_ptr<ComponentExtensionIMEManagerDelegate> delegate);
 
  private:
   friend class InputMethodManagerImplTest;
 
   // CandidateWindowController::Observer overrides:
   virtual void CandidateClicked(int index) OVERRIDE;
   virtual void CandidateWindowOpened() OVERRIDE;
   virtual void CandidateWindowClosed() OVERRIDE;
 
   // Temporarily deactivates all input methods (e.g. Chinese, Japanese, Arabic)
   // since they are not necessary to input a login password. Users are still
   // able to use/switch active keyboard layouts (e.g. US qwerty, US dvorak,
   // French).
   void OnScreenLocked();
 
   // Resumes the original state by activating input methods and/or changing the
   // current input method as needed.
   void OnScreenUnlocked();
 
-  // Returns true if |input_method_id| is in |active_input_method_ids_|.
-  bool InputMethodIsActivated(const std::string& input_method_id);
-
   // Returns true if the given input method config value is a string list
   // that only contains an input method ID of a keyboard layout.
   bool ContainsOnlyKeyboardLayout(const std::vector<std::string>& value);
 
   // Creates and initializes |candidate_window_controller_| if it hasn't been
   // done.
   void MaybeInitializeCandidateWindowController();
 
-  // If |current_input_method_id_| is not in |input_method_ids|, switch to
-  // input_method_ids[0]. If the ID is equal to input_method_ids[N], switch to
-  // input_method_ids[N+1].
-  void SwitchToNextInputMethodInternal(
-      const std::vector<std::string>& input_method_ids,
-      const std::string& current_input_method_id);
+  // Returns Input Method that best matches given id.
+  const InputMethodDescriptor* LookupInputMethod(
+      const std::string& input_method_id,
+      State* state);
 
   // Change system input method.
-  // Returns true if the system input method is changed.
-  bool ChangeInputMethodInternal(const std::string& input_method_id,
-                                 bool show_message);
+  void ChangeInputMethodInternal(const InputMethodDescriptor& descriptor,
+                                 bool show_message,
+                                 bool notify_menu);
 
   // Loads necessary component extensions.
   // TODO(nona): Support dynamical unloading.
-  void LoadNecessaryComponentExtensions();
-
-  // Adds new input method to given list if possible
-  bool EnableInputMethodImpl(
-      const std::string& input_method_id,
-      std::vector<std::string>* new_active_input_method_ids) const;
+  void LoadNecessaryComponentExtensions(State*);
 
   // Starts or stops the system input method framework as needed.
-  // (after list of enabled input methods has been updated)
-  void ReconfigureIMFramework();
+  // (after list of enabled input methods has been updated).
+  // If state is active, active input method is updated.
+  void ReconfigureIMFramework(State* state);
 
   scoped_ptr<InputMethodDelegate> delegate_;
 
   // The current browser status.
-  State state_;
+  UISessionState ui_session_;

[Shu Chen, 2014/08/13 16:15:34]

pls update the comment.

[Alexander Alekseev, 2014/08/13 23:29:32]

Done.

 
   // A list of objects that monitor the manager.
   ObserverList<InputMethodManager::Observer> observers_;
   ObserverList<CandidateWindowObserver> candidate_window_observers_;
 
-  // The input method which was/is selected.
-  InputMethodDescriptor previous_input_method_;
-  InputMethodDescriptor current_input_method_;
-  // The active input method ids cache.
-  std::vector<std::string> active_input_method_ids_;
-
-  // The list of enabled extension IMEs.
-  std::vector<std::string> enabled_extension_imes_;
-
-  // For screen locker. When the screen is locked, |previous_input_method_|,
-  // |current_input_method_|, and |active_input_method_ids_| above are copied
-  // to these "saved" variables.
-  InputMethodDescriptor saved_previous_input_method_;
-  InputMethodDescriptor saved_current_input_method_;
-  std::vector<std::string> saved_active_input_method_ids_;
-
-  // Extra input methods that have been explicitly added to the menu, such as
-  // those created by extension.
-  std::map<std::string, InputMethodDescriptor> extra_input_methods_;
+  scoped_refptr<State> state_;
 
   // The candidate window.  This will be deleted when the APP_TERMINATING
   // message is sent.
   scoped_ptr<CandidateWindowController> candidate_window_controller_;
 
   // An object which provides miscellaneous input method utility functions. Note
   // that |util_| is required to initialize |keyboard_|.
   InputMethodUtil util_;
 
   // An object which provides component extension ime management functions.
   scoped_ptr<ComponentExtensionIMEManager> component_extension_ime_manager_;
 
   // An object for switching XKB layouts and keyboard status like caps lock and
   // auto-repeat interval.
   scoped_ptr<ImeKeyboard> keyboard_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<InputMethodManagerImpl> weak_ptr_factory_;

[Shu Chen, 2014/08/13 16:15:33]

add a blank line.

[Alexander Alekseev, 2014/08/13 23:29:32]

Done.

+  // The engine map from extension_id to an engine.
+  typedef std::map<std::string, InputMethodEngineInterface*> EngineMap;
+  EngineMap engine_map_;
 
-  // The engine map from extension_id to an engine.
-  std::map<std::string, InputMethodEngineInterface*> engine_map_;
+  // Default profile states.
+  std::map<Profile*, scoped_refptr<State> > default_states_;

[Shu Chen, 2014/08/13 16:15:34]

Can you please add comments to explain for what does "default" mean?

Also, holding a profile'd map for states in InputMethodManagerImpl seems
confusing.
Suppose states should be hold in other places which call SetState() to change
the active state.

This map seems only be used as a "cache", and I don't see any code to remove a
profile'd state from this map if a profile is deleted.

[Alexander Alekseev, 2014/08/13 23:29:32]

Before your recent CL, there were two independant ways to initialize
State :
1) From ChromeOS UI code, when we need to apply settings.
2) From Component loader, when extension was loaded.

So I had to put this map in IMM, because this was the only reachable
place for both.

I am ready to move it to UserSessionManager, where it probably should be as soon
as you commit https://codereview.chromium.org/467073002/ .

Actually it should be a map like { UserSession => State }, but we do
not have UserSession object yet.
This is done on purpose (for now), as profiles are never deleted.
But I'll move it out of IMM after your CL.

 
   DISALLOW_COPY_AND_ASSIGN(InputMethodManagerImpl);
 };
 
 }  // namespace input_method
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_INPUT_METHOD_INPUT_METHOD_MANAGER_IMPL_H_