ui/base/ime/input_method_base_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/base/ime/input_method_base.h"
   6
   7 #include "base/gtest_prod_util.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/run_loop.h"
  11 #include "base/scoped_observer.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13 #include "ui/base/ime/dummy_text_input_client.h"
  14 #include "ui/base/ime/input_method_observer.h"
  15 #include "ui/base/ime/text_input_focus_manager.h"
  16 #include "ui/base/ui_base_switches_util.h"
  17 #include "ui/events/event.h"
  18
  19 namespace ui {
  20 namespace {
  21
  22 class ClientChangeVerifier {
  23  public:
  24   ClientChangeVerifier()
  25      : previous_client_(NULL),
  26        next_client_(NULL),
  27        call_expected_(false),
  28        on_will_change_focused_client_called_(false),
  29        on_did_change_focused_client_called_(false),
  30        on_text_input_state_changed_(false) {
  31   }
  32
  33   // Expects that focused text input client will not be changed.
  34   void ExpectClientDoesNotChange() {
  35     previous_client_ = NULL;
  36     next_client_ = NULL;
  37     call_expected_ = false;
  38     on_will_change_focused_client_called_ = false;
  39     on_did_change_focused_client_called_ = false;
  40     on_text_input_state_changed_ = false;
  41   }
  42
  43   // Expects that focused text input client will be changed from
  44   // |previous_client| to |next_client|.
  45   void ExpectClientChange(TextInputClient* previous_client,
  46                           TextInputClient* next_client) {
  47     previous_client_ = previous_client;
  48     next_client_ = next_client;
  49     call_expected_ = true;
  50     on_will_change_focused_client_called_ = false;
  51     on_did_change_focused_client_called_ = false;
  52     on_text_input_state_changed_ = false;
  53   }
  54
  55   // Verifies the result satisfies the expectation or not.
  56   void Verify() {
  57     if (switches::IsTextInputFocusManagerEnabled()) {
  58       EXPECT_FALSE(on_will_change_focused_client_called_);
  59       EXPECT_FALSE(on_did_change_focused_client_called_);
  60       EXPECT_FALSE(on_text_input_state_changed_);
  61     } else {
  62       EXPECT_EQ(call_expected_, on_will_change_focused_client_called_);
  63       EXPECT_EQ(call_expected_, on_did_change_focused_client_called_);
  64       EXPECT_EQ(call_expected_, on_text_input_state_changed_);
  65     }
  66   }
  67
  68   void OnWillChangeFocusedClient(TextInputClient* focused_before,
  69                                  TextInputClient* focused) {
  70     EXPECT_TRUE(call_expected_);
  71
  72     // Check arguments
  73     EXPECT_EQ(previous_client_, focused_before);
  74     EXPECT_EQ(next_client_, focused);
  75
  76     // Check call order
  77     EXPECT_FALSE(on_will_change_focused_client_called_);
  78     EXPECT_FALSE(on_did_change_focused_client_called_);
  79     EXPECT_FALSE(on_text_input_state_changed_);
  80
  81     on_will_change_focused_client_called_ = true;
  82   }
  83
  84   void OnDidChangeFocusedClient(TextInputClient* focused_before,
  85                                 TextInputClient* focused) {
  86     EXPECT_TRUE(call_expected_);
  87
  88     // Check arguments
  89     EXPECT_EQ(previous_client_, focused_before);
  90     EXPECT_EQ(next_client_, focused);
  91
  92     // Check call order
  93     EXPECT_TRUE(on_will_change_focused_client_called_);
  94     EXPECT_FALSE(on_did_change_focused_client_called_);
  95     EXPECT_FALSE(on_text_input_state_changed_);
  96
  97     on_did_change_focused_client_called_ = true;
  98  }
  99
 100   void OnTextInputStateChanged(const TextInputClient* client) {
 101     EXPECT_TRUE(call_expected_);
 102
 103     // Check arguments
 104     EXPECT_EQ(next_client_, client);
 105
 106     // Check call order
 107     EXPECT_TRUE(on_will_change_focused_client_called_);
 108     EXPECT_TRUE(on_did_change_focused_client_called_);
 109     EXPECT_FALSE(on_text_input_state_changed_);
 110
 111     on_text_input_state_changed_ = true;
 112  }
 113
 114  private:
 115   TextInputClient* previous_client_;
 116   TextInputClient* next_client_;
 117   bool call_expected_;
 118   bool on_will_change_focused_client_called_;
 119   bool on_did_change_focused_client_called_;
 120   bool on_text_input_state_changed_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(ClientChangeVerifier);
 123 };
 124
 125 class InputMethodBaseTest : public testing::Test {
 126  protected:
 127   InputMethodBaseTest() {
 128   }
 129   virtual ~InputMethodBaseTest() {
 130   }
 131
 132   virtual void SetUp() {
 133     message_loop_.reset(new base::MessageLoopForUI);
 134   }
 135
 136   virtual void TearDown() {
 137     message_loop_.reset();
 138   }
 139
 140  private:
 141   scoped_ptr<base::MessageLoop> message_loop_;
 142   DISALLOW_COPY_AND_ASSIGN(InputMethodBaseTest);
 143 };
 144
 145 class MockInputMethodBase : public InputMethodBase {
 146  public:
 147   // Note: this class does not take the ownership of |verifier|.
 148   MockInputMethodBase(ClientChangeVerifier* verifier) : verifier_(verifier) {
 149   }
 150   virtual ~MockInputMethodBase() {
 151   }
 152
 153  private:
 154   // Overriden from InputMethod.
 155   virtual bool OnUntranslatedIMEMessage(
 156       const base::NativeEvent& event,
 157       InputMethod::NativeEventResult* result) OVERRIDE {
 158     return false;
 159   }
 160   virtual bool DispatchKeyEvent(const ui::KeyEvent&) OVERRIDE {
 161     return false;
 162   }
 163   virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE {
 164   }
 165   virtual void CancelComposition(const TextInputClient* client) OVERRIDE {
 166   }
 167   virtual void OnInputLocaleChanged() OVERRIDE {
 168   }
 169   virtual std::string GetInputLocale() OVERRIDE{
 170     return "";
 171   }
 172   virtual bool IsActive() OVERRIDE {
 173     return false;
 174   }
 175   virtual bool IsCandidatePopupOpen() const OVERRIDE {
 176     return false;
 177   }
 178   // Overriden from InputMethodBase.
 179   virtual void OnWillChangeFocusedClient(TextInputClient* focused_before,
 180                                          TextInputClient* focused) OVERRIDE {
 181     verifier_->OnWillChangeFocusedClient(focused_before, focused);
 182   }
 183
 184   virtual void OnDidChangeFocusedClient(TextInputClient* focused_before,
 185                                         TextInputClient* focused) OVERRIDE {
 186     verifier_->OnDidChangeFocusedClient(focused_before, focused);
 187   }
 188
 189   ClientChangeVerifier* verifier_;
 190
 191   FRIEND_TEST_ALL_PREFIXES(InputMethodBaseTest, CandidateWindowEvents);
 192   DISALLOW_COPY_AND_ASSIGN(MockInputMethodBase);
 193 };
 194
 195 class MockInputMethodObserver : public InputMethodObserver {
 196  public:
 197   // Note: this class does not take the ownership of |verifier|.
 198   explicit MockInputMethodObserver(ClientChangeVerifier* verifier)
 199       : verifier_(verifier) {
 200   }
 201   virtual ~MockInputMethodObserver() {
 202   }
 203
 204  private:
 205   virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE {
 206   }
 207   virtual void OnFocus() OVERRIDE {
 208   }
 209   virtual void OnBlur() OVERRIDE {
 210   }
 211   virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE {
 212   }
 213   virtual void OnTextInputStateChanged(const TextInputClient* client) OVERRIDE {
 214     verifier_->OnTextInputStateChanged(client);
 215   }
 216   virtual void OnShowImeIfNeeded() OVERRIDE {
 217   }
 218   virtual void OnInputMethodDestroyed(const InputMethod* client) OVERRIDE {
 219   }
 220
 221   ClientChangeVerifier* verifier_;
 222   DISALLOW_COPY_AND_ASSIGN(MockInputMethodObserver);
 223 };
 224
 225 class MockTextInputClient : public DummyTextInputClient {
 226  public:
 227   MockTextInputClient()
 228       : shown_event_count_(0), updated_event_count_(0), hidden_event_count_(0) {
 229   }
 230   virtual ~MockTextInputClient() {
 231   }
 232
 233   virtual void OnCandidateWindowShown() OVERRIDE {
 234     ++shown_event_count_;
 235   }
 236   virtual void OnCandidateWindowUpdated() OVERRIDE {
 237     ++updated_event_count_;
 238   }
 239   virtual void OnCandidateWindowHidden() OVERRIDE {
 240     ++hidden_event_count_;
 241   }
 242
 243   int shown_event_count() const { return shown_event_count_; }
 244   int updated_event_count() const { return updated_event_count_; }
 245   int hidden_event_count() const { return hidden_event_count_; }
 246
 247  private:
 248   int shown_event_count_;
 249   int updated_event_count_;
 250   int hidden_event_count_;
 251 };
 252
 253 typedef ScopedObserver<InputMethod, InputMethodObserver>
 254     InputMethodScopedObserver;
 255
 256 void SetFocusedTextInputClient(InputMethod* input_method,
 257                                TextInputClient* text_input_client) {
 258   if (switches::IsTextInputFocusManagerEnabled()) {
 259     TextInputFocusManager::GetInstance()->FocusTextInputClient(
 260         text_input_client);
 261   } else {
 262     input_method->SetFocusedTextInputClient(text_input_client);
 263   }
 264 }
 265
 266 TEST_F(InputMethodBaseTest, SetFocusedTextInputClient) {
 267   DummyTextInputClient text_input_client_1st;
 268   DummyTextInputClient text_input_client_2nd;
 269
 270   ClientChangeVerifier verifier;
 271   MockInputMethodBase input_method(&verifier);
 272   MockInputMethodObserver input_method_observer(&verifier);
 273   InputMethodScopedObserver scoped_observer(&input_method_observer);
 274   scoped_observer.Add(&input_method);
 275
 276   // Assume that the top-level-widget gains focus.
 277   input_method.OnFocus();
 278
 279   {
 280     SCOPED_TRACE("Focus from NULL to 1st TextInputClient");
 281
 282     ASSERT_EQ(NULL, input_method.GetTextInputClient());
 283     verifier.ExpectClientChange(NULL, &text_input_client_1st);
 284     SetFocusedTextInputClient(&input_method, &text_input_client_1st);
 285     EXPECT_EQ(&text_input_client_1st, input_method.GetTextInputClient());
 286     verifier.Verify();
 287   }
 288
 289   {
 290     SCOPED_TRACE("Redundant focus events must be ignored");
 291     verifier.ExpectClientDoesNotChange();
 292     SetFocusedTextInputClient(&input_method, &text_input_client_1st);
 293     verifier.Verify();
 294   }
 295
 296   {
 297     SCOPED_TRACE("Focus from 1st to 2nd TextInputClient");
 298
 299     ASSERT_EQ(&text_input_client_1st, input_method.GetTextInputClient());
 300     verifier.ExpectClientChange(&text_input_client_1st,
 301                                 &text_input_client_2nd);
 302     SetFocusedTextInputClient(&input_method, &text_input_client_2nd);
 303     EXPECT_EQ(&text_input_client_2nd, input_method.GetTextInputClient());
 304     verifier.Verify();
 305   }
 306
 307   {
 308     SCOPED_TRACE("Focus from 2nd TextInputClient to NULL");
 309
 310     ASSERT_EQ(&text_input_client_2nd, input_method.GetTextInputClient());
 311     verifier.ExpectClientChange(&text_input_client_2nd, NULL);
 312     SetFocusedTextInputClient(&input_method, NULL);
 313     EXPECT_EQ(NULL, input_method.GetTextInputClient());
 314     verifier.Verify();
 315   }
 316
 317   {
 318     SCOPED_TRACE("Redundant focus events must be ignored");
 319     verifier.ExpectClientDoesNotChange();
 320     SetFocusedTextInputClient(&input_method, NULL);
 321     verifier.Verify();
 322   }
 323 }
 324
 325 TEST_F(InputMethodBaseTest, DetachTextInputClient) {
 326   // DetachTextInputClient is not supported when IsTextInputFocusManagerEnabled.
 327   if (switches::IsTextInputFocusManagerEnabled())
 328     return;
 329
 330   DummyTextInputClient text_input_client;
 331   DummyTextInputClient text_input_client_the_other;
 332
 333   ClientChangeVerifier verifier;
 334   MockInputMethodBase input_method(&verifier);
 335   MockInputMethodObserver input_method_observer(&verifier);
 336   InputMethodScopedObserver scoped_observer(&input_method_observer);
 337   scoped_observer.Add(&input_method);
 338
 339   // Assume that the top-level-widget gains focus.
 340   input_method.OnFocus();
 341
 342   // Initialize for the next test.
 343   {
 344     verifier.ExpectClientChange(NULL, &text_input_client);
 345     input_method.SetFocusedTextInputClient(&text_input_client);
 346     verifier.Verify();
 347   }
 348
 349   {
 350     SCOPED_TRACE("DetachTextInputClient must be ignored for other clients");
 351     ASSERT_EQ(&text_input_client, input_method.GetTextInputClient());
 352     verifier.ExpectClientDoesNotChange();
 353     input_method.DetachTextInputClient(&text_input_client_the_other);
 354     EXPECT_EQ(&text_input_client, input_method.GetTextInputClient());
 355     verifier.Verify();
 356   }
 357
 358   {
 359     SCOPED_TRACE("DetachTextInputClient must succeed even after the "
 360                  "top-level loses the focus");
 361
 362     ASSERT_EQ(&text_input_client, input_method.GetTextInputClient());
 363     input_method.OnBlur();
 364     input_method.OnFocus();
 365     verifier.ExpectClientChange(&text_input_client, NULL);
 366     input_method.DetachTextInputClient(&text_input_client);
 367     EXPECT_EQ(NULL, input_method.GetTextInputClient());
 368     verifier.Verify();
 369   }
 370 }
 371
 372 TEST_F(InputMethodBaseTest, CandidateWindowEvents) {
 373   MockTextInputClient text_input_client;
 374
 375   {
 376     ClientChangeVerifier verifier;
 377     MockInputMethodBase input_method_base(&verifier);
 378     input_method_base.OnFocus();
 379
 380     verifier.ExpectClientChange(NULL, &text_input_client);
 381     SetFocusedTextInputClient(&input_method_base, &text_input_client);
 382
 383     EXPECT_EQ(0, text_input_client.shown_event_count());
 384     EXPECT_EQ(0, text_input_client.updated_event_count());
 385     EXPECT_EQ(0, text_input_client.hidden_event_count());
 386
 387     input_method_base.OnCandidateWindowShown();
 388     base::RunLoop().RunUntilIdle();
 389
 390     EXPECT_EQ(1, text_input_client.shown_event_count());
 391     EXPECT_EQ(0, text_input_client.updated_event_count());
 392     EXPECT_EQ(0, text_input_client.hidden_event_count());
 393
 394     input_method_base.OnCandidateWindowUpdated();
 395     base::RunLoop().RunUntilIdle();
 396
 397     EXPECT_EQ(1, text_input_client.shown_event_count());
 398     EXPECT_EQ(1, text_input_client.updated_event_count());
 399     EXPECT_EQ(0, text_input_client.hidden_event_count());
 400
 401     input_method_base.OnCandidateWindowHidden();
 402     base::RunLoop().RunUntilIdle();
 403
 404     EXPECT_EQ(1, text_input_client.shown_event_count());
 405     EXPECT_EQ(1, text_input_client.updated_event_count());
 406     EXPECT_EQ(1, text_input_client.hidden_event_count());
 407
 408     input_method_base.OnCandidateWindowShown();
 409   }
 410
 411   // If InputMethod is deleted immediately after an event happens, but before
 412   // its callback is invoked, the callback will be cancelled.
 413   base::RunLoop().RunUntilIdle();
 414   EXPECT_EQ(1, text_input_client.shown_event_count());
 415   EXPECT_EQ(1, text_input_client.updated_event_count());
 416   EXPECT_EQ(1, text_input_client.hidden_event_count());
 417 }
 418
 419 }  // namespace
 420 }  // namespace ui