Implements InputMethodTSF::IsCandidatePopupOpen().

ui/base/ime/input_method_tsf.cc

 // Copyright (c) 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 "ui/base/ime/input_method_tsf.h"
 
 #include "ui/base/ime/text_input_client.h"
 #include "ui/base/ime/win/tsf_bridge.h"
+#include "ui/base/ime/win/tsf_event_router.h"
 
 namespace ui {
 
+class InputMethodTSF::TSFEventObserver : public TSFEventRouterObserver {
+ public:
+  TSFEventObserver() : is_candidate_popup_open_(false) {}
+
+  // Returns true if we know for sure that a candidate window (or IME suggest,
+  // etc.) is open.
+  bool IsCandidatePopupOpen() const { return is_candidate_popup_open_; }
+
+  // Overridden from TSFEventRouterObserver:
+  virtual void OnCandidateWindowCountChanged(size_t window_count) OVERRIDE {
+    is_candidate_popup_open_ = (window_count != 0);
+  }
+
+ private:
+  // True if we know for sure that a candidate window is open.
+  bool is_candidate_popup_open_;
+
+  DISALLOW_COPY_AND_ASSIGN(TSFEventObserver);
+};
+
 InputMethodTSF::InputMethodTSF(internal::InputMethodDelegate* delegate,
                                HWND toplevel_window_handle)
-    : InputMethodWin(delegate, toplevel_window_handle) {
+    : InputMethodWin(delegate, toplevel_window_handle),
+      tsf_event_observer_(new TSFEventObserver()),
+      tsf_event_router_(new TSFEventRouter(tsf_event_observer_.get())) {
   // In non-Aura environment, appropriate callbacks to OnFocus() and OnBlur()
   // are not implemented yet. To work around this limitation, here we use
   // "always focused" model.
   // TODO(ime): Fix the caller of OnFocus() and OnBlur() so that appropriate
   // focus event will be passed.
   InputMethodWin::OnFocus();
 }
 
+InputMethodTSF::~InputMethodTSF() {}
+
 void InputMethodTSF::OnFocus() {
-  // Ignore OnFocus event for "always focused" model. See the comment in the
-  // constructor.
+  // Do not call baseclass' OnFocus() and discard the event being in
+  // "always focused" model.  See the comment in the constructor.
   // TODO(ime): Implement OnFocus once the callers are fixed.
+
+  tsf_event_router_->SetManager(
+      ui::TSFBridge::GetInstance()->GetThreadManager());
 }
 
 void InputMethodTSF::OnBlur() {
-  // Ignore OnBlur event for "always focused" model. See the comment in the
-  // constructor.
+  // Do not call baseclass' OnBlur() and discard the event being in
+  // "always focused" model.  See the comment in the constructor.
   // TODO(ime): Implement OnFocus once the callers are fixed.
+
+  tsf_event_router_->SetManager(NULL);
 }
 
 bool InputMethodTSF::OnUntranslatedIMEMessage(
     const base::NativeEvent& event, InputMethod::NativeEventResult* result) {
   LRESULT original_result = 0;
   BOOL handled = FALSE;
   // Even when TSF is enabled, following IMM32/Win32 messages must be handled.
   switch (event.message) {
     case WM_IME_REQUEST:
       // Some TSF-native TIPs (Text Input Processors) such as ATOK and Mozc
@@ skipping 49 matching lines @@
   } else if (!client) {
     // SetFocusedTextInputClient(NULL) must be interpreted as
     // "Remove the attached client".
     ui::TSFBridge::GetInstance()->RemoveFocusedClient(
         ui::TSFBridge::GetInstance()->GetFocusedTextInputClient());
   }
   InputMethodWin::SetFocusedTextInputClient(client);
 }
 
 bool InputMethodTSF::IsCandidatePopupOpen() const {
-  // TODO(yukishiino): Implement this method.
-  return false;
+  return tsf_event_observer_->IsCandidatePopupOpen();
 }
 
 void InputMethodTSF::OnWillChangeFocusedClient(TextInputClient* focused_before,
                                                TextInputClient* focused) {
   if (IsWindowFocused(focused_before)) {
     ConfirmCompositionText();
     ui::TSFBridge::GetInstance()->RemoveFocusedClient(focused_before);
   }
 }
 
@@ skipping 19 matching lines @@
 }
 
 bool InputMethodTSF::IsWindowFocused(const TextInputClient* client) const {
   if (!client)
     return false;
   HWND attached_window_handle = GetAttachedWindowHandle(client);
   return attached_window_handle && GetFocus() == attached_window_handle;
 }
 
 }  // namespace ui