(Chrome OS) Notify when the candidate window is opened/closed.

chrome/browser/chromeos/input_method/input_method_manager.cc

 // Copyright (c) 2011 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.h"
 
 #include <algorithm>
 
 #include <glib.h>
 
@@ skipping 111 matching lines @@
   }
   return false;
 }
 
 }  // namespace
 
 namespace chromeos {
 namespace input_method {
 
 // The implementation of InputMethodManager.
-class InputMethodManagerImpl : public HotkeyManager::Observer,
-                               public InputMethodManager,
-                               public content::NotificationObserver,
-                               public IBusController::Observer {
+class InputMethodManagerImpl
+    : public HotkeyManager::Observer,
+      public InputMethodManager,
+      public content::NotificationObserver,
+#if !defined(USE_VIRTUAL_KEYBOARD)
+      public CandidateWindowController::Observer,
+#endif
+      public IBusController::Observer {
  public:
   InputMethodManagerImpl()
       : ibus_controller_(IBusController::Create()),
         should_launch_ime_(false),
         ime_connected_(false),
         defer_ime_startup_(false),
         enable_auto_ime_shutdown_(true),
         shutting_down_(false),
         ibus_daemon_process_handle_(base::kNullProcessHandle),
         util_(ibus_controller_->GetSupportedInputMethods()),
@@ skipping 25 matching lines @@
       }
     }
 
     AddHotkeys();
     hotkey_manager_.AddObserver(this);
   }
 
   virtual ~InputMethodManagerImpl() {
     hotkey_manager_.RemoveObserver(this);
     ibus_controller_->RemoveObserver(this);
+#if !defined(USE_VIRTUAL_KEYBOARD)
+    if (candidate_window_controller_.get())
+      candidate_window_controller_->RemoveObserver(this);
+#endif
   }
 
   virtual void AddObserver(InputMethodManager::Observer* observer) {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(InputMethodManager::Observer* observer) {
     observers_.RemoveObserver(observer);
   }
 
+  virtual void AddCandidateWindowObserver(
+      InputMethodManager::CandidateWindowObserver* observer) {
+    candidate_window_observers_.AddObserver(observer);
+  }
+
+  virtual void RemoveCandidateWindowObserver(
+      InputMethodManager::CandidateWindowObserver* observer) {
+    candidate_window_observers_.RemoveObserver(observer);
+  }
+
   virtual void AddPreLoginPreferenceObserver(
       InputMethodManager::PreferenceObserver* observer) {
     if (!pre_login_preference_observers_.size()) {
       observer->FirstObserverIsAdded(this);
     }
     pre_login_preference_observers_.AddObserver(observer);
   }
 
   virtual void RemovePreLoginPreferenceObserver(
       InputMethodManager::PreferenceObserver* observer) {
@@ skipping 321 matching lines @@
         break;
       case kJapaneseInputMethod:
       case kJapaneseLayout:
       case kJapaneseInputMethodOrLayout:
       case kKoreanInputMethodOrLayout:
         SwitchToInputMethod(event);
         break;
     }
   }
 
+  virtual void CandidateWindowOpened() {
+    FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
+                      candidate_window_observers_,
+                      CandidateWindowOpened(this));
+  }
+
+  virtual void CandidateWindowClosed() {
+    FOR_EACH_OBSERVER(InputMethodManager::CandidateWindowObserver,
+                      candidate_window_observers_,
+                      CandidateWindowClosed(this));
+  }
+
   virtual void SwitchToNextInputMethod() {
     // Sanity checks.
     if (active_input_method_ids_.empty()) {
       LOG(ERROR) << "active input method is empty";
       return;
     }
     if (current_input_method_.id().empty()) {
       LOG(ERROR) << "current_input_method_ is unknown";
       return;
     }
@@ skipping 556 matching lines @@
     }
 
     if (shutting_down_) {
       NOTREACHED() << "Trying to launch input method while shutting down";
       return false;
     }
 
 #if !defined(USE_VIRTUAL_KEYBOARD)
     if (!candidate_window_controller_.get()) {
       candidate_window_controller_.reset(new CandidateWindowController);
-      if (!candidate_window_controller_->Init()) {
+      if (candidate_window_controller_->Init()) {
+        candidate_window_controller_->AddObserver(this);
+      } else {
         LOG(WARNING) << "Failed to initialize the candidate window controller";
       }
     }
 #endif
 
     if (ibus_daemon_process_handle_ != base::kNullProcessHandle) {
       return false;  // ibus-daemon is already running.
     }
 
     // TODO(zork): Send output to /var/log/ibus.log
@@ skipping 55 matching lines @@
   // content::NotificationObserver implementation:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) {
     // Stop the input method daemon on browser shutdown.
     if (type == content::NOTIFICATION_APP_TERMINATING) {
       shutting_down_ = true;
       notification_registrar_.RemoveAll();
       StopInputMethodDaemon();
 #if !defined(USE_VIRTUAL_KEYBOARD)
+      if (candidate_window_controller_.get())
+        candidate_window_controller_->RemoveObserver(this);
       candidate_window_controller_.reset(NULL);
 #endif
     }
   }
 
   void UpdateInputMethodSpecificHotkeys() {
     // Remove all input method specific hotkeys first.
     for (size_t i = 0; i < kInputMethodSpecificHotkeySettingsLen; ++i) {
       hotkey_manager_.RemoveHotkey(
           kInputMethodSpecificHotkeySettings[i].event_id);
@@ skipping 100 matching lines @@
     if (iter == ids.end()) {
       iter = ids.begin();
     }
     ChangeInputMethod(*iter);
   }
 
   // The IBus controller is used to control the input method status and
   // allow allow callbacks when the input method status changes.
   scoped_ptr<IBusController> ibus_controller_;
   ObserverList<InputMethodManager::Observer> observers_;
+  ObserverList<InputMethodManager::CandidateWindowObserver>
+      candidate_window_observers_;
   ObserverList<PreferenceObserver> pre_login_preference_observers_;
   ObserverList<PreferenceObserver> post_login_preference_observers_;
   ObserverList<VirtualKeyboardObserver> virtual_keyboard_observers_;
 
   // The input method which was/is selected.
   InputMethodDescriptor previous_input_method_;
   InputMethodDescriptor current_input_method_;
 
   // The input method properties which the current input method uses. The list
   // might be empty when no input method is used.
@@ skipping 78 matching lines @@
   return InputMethodManagerImpl::GetInstance();
 }
 
 }  // namespace input_method
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     chromeos::input_method::InputMethodManagerImpl);