Support InputMethodObserver in RemoteInputMethodWin

ui/base/ime/remote_input_method_win_unittest.cc

 // Copyright 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/remote_input_method_win.h"
 
 #include <InputScope.h>
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
+#include "base/scoped_observer.h"
 #include "base/strings/string16.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ime/dummy_text_input_client.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_delegate.h"
+#include "ui/base/ime/input_method_observer.h"
 #include "ui/base/ime/remote_input_method_delegate_win.h"
 #include "ui/events/event.h"
 
 namespace ui {
 namespace {
 
 class MockTextInputClient : public DummyTextInputClient {
  public:
   MockTextInputClient()
       : text_input_type_(TEXT_INPUT_TYPE_NONE),
@@ skipping 127 matching lines @@
     composition_character_bounds_ = composition_character_bounds;
   }
 
   bool cancel_composition_called_;
   bool text_input_client_updated_called_;
   std::vector<int32> input_scopes_;
   std::vector<gfx::Rect> composition_character_bounds_;
   DISALLOW_COPY_AND_ASSIGN(MockRemoteInputMethodDelegateWin);
 };
 
+class MockInputMethodObserver : public InputMethodObserver {
+ public:
+  MockInputMethodObserver()
+    : on_text_input_type_changed_(0),
+      on_caret_bounds_changed_(0),
+      on_input_locale_changed_(0),
+      on_text_input_state_changed_(0),
+      on_input_method_destroyed_changed_(0) {
+  }
+  virtual ~MockInputMethodObserver() {
+  }
+  void Reset() {
+    on_text_input_type_changed_ = 0;
+    on_caret_bounds_changed_ = 0;
+    on_input_locale_changed_ = 0;
+    on_text_input_state_changed_ = 0;
+    on_input_method_destroyed_changed_ = 0;
+  }
+  size_t on_text_input_type_changed() const {
+    return on_text_input_type_changed_;
+  }
+  size_t on_caret_bounds_changed() const {
+    return on_caret_bounds_changed_;
+  }
+  size_t on_input_locale_changed() const {
+    return on_input_locale_changed_;
+  }
+  size_t on_text_input_state_changed() const {
+    return on_text_input_state_changed_;
+  }
+  size_t on_input_method_destroyed_changed() const {
+    return on_input_method_destroyed_changed_;
+  }
+
+ private:
+  // Overriden from InputMethodObserver.
+  virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE {
+    ++on_text_input_type_changed_;
+  }
+  virtual void OnFocus() OVERRIDE {
+  }
+  virtual void OnBlur() OVERRIDE {
+  }
+  virtual void OnUntranslatedIMEMessage(
+    const base::NativeEvent& event) OVERRIDE {
+  }
+  virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE {
+    ++on_caret_bounds_changed_;
+  }
+  virtual void OnInputLocaleChanged() OVERRIDE {
+    ++on_input_locale_changed_;
+  }
+  virtual void OnTextInputStateChanged(const TextInputClient* client) OVERRIDE {
+    ++on_text_input_state_changed_;
+  }
+  virtual void OnInputMethodDestroyed(const InputMethod* client) OVERRIDE {
+    ++on_input_method_destroyed_changed_;
+  }
+
+  size_t on_text_input_type_changed_;
+  size_t on_caret_bounds_changed_;
+  size_t on_input_locale_changed_;
+  size_t on_text_input_state_changed_;
+  size_t on_input_method_destroyed_changed_;
+  DISALLOW_COPY_AND_ASSIGN(MockInputMethodObserver);
+};
+
+typedef ScopedObserver<InputMethod, InputMethodObserver>
+    InputMethodScopedObserver;
+
 TEST(RemoteInputMethodWinTest, RemoteInputMethodPrivateWin) {
   InputMethod* other_ptr = static_cast<InputMethod*>(NULL) + 1;
 
   // Use typed NULL to make EXPECT_NE happy until nullptr becomes available.
   RemoteInputMethodPrivateWin* kNull =
       static_cast<RemoteInputMethodPrivateWin*>(NULL);
   EXPECT_EQ(kNull, RemoteInputMethodPrivateWin::Get(other_ptr));
 
   MockInputMethodDelegate delegate_;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
@@ skipping 117 matching lines @@
   ASSERT_EQ(1, mock_remote_delegate.input_scopes().size());
   EXPECT_EQ(IS_URL, mock_remote_delegate.input_scopes()[0]);
 
   // State must be cleared by DetachTextInputClient
   mock_remote_delegate.Reset();
   input_method->DetachTextInputClient(&mock_text_input_client);
   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
   EXPECT_TRUE(mock_remote_delegate.composition_character_bounds().empty());
   EXPECT_TRUE(mock_remote_delegate.input_scopes().empty());
 }
+
 TEST(RemoteInputMethodWinTest, OnCaretBoundsChanged) {
   MockInputMethodDelegate delegate_;
   MockTextInputClient mock_text_input_client;
   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 
   // This must not cause a crash.
   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 
   mock_text_input_client.set_caret_bounds(gfx::Rect(10, 0, 10, 20));
   input_method->SetFocusedTextInputClient(&mock_text_input_client);
@@ skipping 254 matching lines @@
 
   // TextInputClient is now focused here.
 
   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
   EXPECT_EQ(L"A", mock_text_input_client.inserted_text());
   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
   delegate_.Reset();
   mock_text_input_client.Reset();
 }
 
+TEST(RemoteInputMethodWinTest, OnTextInputStateChanged_Observer) {
+  DummyTextInputClient text_input_client;
+  DummyTextInputClient text_input_client_the_other;
+
+  MockInputMethodObserver input_method_observer;
+  MockInputMethodDelegate delegate_;
+  scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
+  InputMethodScopedObserver scoped_observer(&input_method_observer);
+  scoped_observer.Add(input_method.get());
+
+  input_method->SetFocusedTextInputClient(&text_input_client);
+  ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
+  EXPECT_EQ(1u, input_method_observer.on_text_input_state_changed());
+  input_method_observer.Reset();
+
+  input_method->SetFocusedTextInputClient(&text_input_client);
+  ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
+  EXPECT_EQ(0u, input_method_observer.on_text_input_state_changed());
+  input_method_observer.Reset();
+
+  input_method->SetFocusedTextInputClient(&text_input_client_the_other);
+  ASSERT_EQ(&text_input_client_the_other, input_method->GetTextInputClient());
+  EXPECT_EQ(1u, input_method_observer.on_text_input_state_changed());
+  input_method_observer.Reset();
+
+  input_method->DetachTextInputClient(&text_input_client_the_other);
+  ASSERT_TRUE(input_method->GetTextInputClient() == NULL);
+  EXPECT_EQ(1u, input_method_observer.on_text_input_state_changed());
+  input_method_observer.Reset();
+}
+
+TEST(RemoteInputMethodWinTest, OnCaretBoundsChanged_Observer) {
+  DummyTextInputClient text_input_client;
+  DummyTextInputClient text_input_client_the_other;
+
+  MockInputMethodObserver input_method_observer;
+  MockInputMethodDelegate delegate_;
+  scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
+  InputMethodScopedObserver scoped_observer(&input_method_observer);
+  scoped_observer.Add(input_method.get());
+
+  {
+    SCOPED_TRACE("OnCaretBoundsChanged callback must not be fired when no text "
+                 "input client is focused");
+    ASSERT_EQ(NULL, input_method->GetTextInputClient());
+
+    input_method_observer.Reset();
+    input_method->OnCaretBoundsChanged(&text_input_client);
+    EXPECT_EQ(0u, input_method_observer.on_caret_bounds_changed());
+    input_method->OnCaretBoundsChanged(NULL);
+    EXPECT_EQ(0u, input_method_observer.on_caret_bounds_changed());
+  }
+
+  {
+    SCOPED_TRACE("OnCaretBoundsChanged callback must be fired when and only "
+                 "the event is notified from the focused text input client");
+
+    input_method->SetFocusedTextInputClient(&text_input_client);
+    ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
+
+    // Must fire the event
+    input_method_observer.Reset();
+    input_method->OnCaretBoundsChanged(&text_input_client);
+    EXPECT_EQ(1u, input_method_observer.on_caret_bounds_changed());
+
+    // Must not fire the event
+    input_method_observer.Reset();
+    input_method->OnCaretBoundsChanged(NULL);
+    EXPECT_EQ(0u, input_method_observer.on_caret_bounds_changed());
+
+    // Must not fire the event
+    input_method_observer.Reset();
+    input_method->OnCaretBoundsChanged(&text_input_client_the_other);
+    EXPECT_EQ(0u, input_method_observer.on_caret_bounds_changed());
+  }
+}
+
+TEST(RemoteInputMethodWinTest, OnInputLocaleChanged_Observer) {
+  DummyTextInputClient text_input_client;
+
+  MockInputMethodObserver input_method_observer;
+
+  MockInputMethodDelegate delegate_;
+  scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
+  InputMethodScopedObserver scoped_observer(&input_method_observer);
+  scoped_observer.Add(input_method.get());
+
+  {
+    SCOPED_TRACE("OnInputLocaleChanged callback can be fired even when no text "
+                 "input client is focused");
+    ASSERT_EQ(NULL, input_method->GetTextInputClient());
+
+    input_method_observer.Reset();
+    input_method->OnInputLocaleChanged();
+    EXPECT_EQ(1u, input_method_observer.on_input_locale_changed());
+
+    input_method->SetFocusedTextInputClient(&text_input_client);
+    input_method_observer.Reset();
+    input_method->OnInputLocaleChanged();
+    EXPECT_EQ(1u, input_method_observer.on_input_locale_changed());
+  }
+}
+
+TEST(RemoteInputMethodWinTest, OnInputMethodDestroyed_Observer) {
+  DummyTextInputClient text_input_client;
+  DummyTextInputClient text_input_client_the_other;
+
+  MockInputMethodObserver input_method_observer;
+  InputMethodScopedObserver scoped_observer(&input_method_observer);
+
+  MockInputMethodDelegate delegate_;
+  scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
+  input_method->AddObserver(&input_method_observer);
+
+  EXPECT_EQ(0u, input_method_observer.on_input_method_destroyed_changed());
+  input_method.reset();
+  EXPECT_EQ(1u, input_method_observer.on_input_method_destroyed_changed());
+}
+
 }  // namespace
 }  // namespace ui