ui/base/ime/remote_input_method_win_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/remote_input_method_win.h"
   6
   7 #include <InputScope.h>
   8
   9 #include <vector>
  10
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/scoped_observer.h"
  13 #include "base/strings/string16.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15 #include "ui/base/ime/composition_text.h"
  16 #include "ui/base/ime/dummy_text_input_client.h"
  17 #include "ui/base/ime/input_method.h"
  18 #include "ui/base/ime/input_method_delegate.h"
  19 #include "ui/base/ime/input_method_observer.h"
  20 #include "ui/base/ime/remote_input_method_delegate_win.h"
  21 #include "ui/events/event.h"
  22
  23 namespace ui {
  24 namespace {
  25
  26 class MockTextInputClient : public DummyTextInputClient {
  27  public:
  28   MockTextInputClient()
  29       : text_input_type_(TEXT_INPUT_TYPE_NONE),
  30         text_input_mode_(TEXT_INPUT_MODE_DEFAULT),
  31         call_count_set_composition_text_(0),
  32         call_count_insert_char_(0),
  33         call_count_insert_text_(0),
  34         emulate_pepper_flash_(false),
  35         is_candidate_window_shown_called_(false),
  36         is_candidate_window_hidden_called_(false) {
  37   }
  38
  39   size_t call_count_set_composition_text() const {
  40     return call_count_set_composition_text_;
  41   }
  42   const base::string16& inserted_text() const {
  43     return inserted_text_;
  44   }
  45   size_t call_count_insert_char() const {
  46     return call_count_insert_char_;
  47   }
  48   size_t call_count_insert_text() const {
  49     return call_count_insert_text_;
  50   }
  51   bool is_candidate_window_shown_called() const {
  52     return is_candidate_window_shown_called_;
  53   }
  54   bool is_candidate_window_hidden_called() const {
  55     return is_candidate_window_hidden_called_;
  56   }
  57   void Reset() {
  58     text_input_type_ = TEXT_INPUT_TYPE_NONE;
  59     text_input_mode_ = TEXT_INPUT_MODE_DEFAULT;
  60     call_count_set_composition_text_ = 0;
  61     inserted_text_.clear();
  62     call_count_insert_char_ = 0;
  63     call_count_insert_text_ = 0;
  64     caret_bounds_ = gfx::Rect();
  65     composition_character_bounds_.clear();
  66     emulate_pepper_flash_ = false;
  67     is_candidate_window_shown_called_ = false;
  68     is_candidate_window_hidden_called_ = false;
  69   }
  70   void set_text_input_type(ui::TextInputType type) {
  71     text_input_type_ = type;
  72   }
  73   void set_text_input_mode(ui::TextInputMode mode) {
  74     text_input_mode_ = mode;
  75   }
  76   void set_caret_bounds(const gfx::Rect& caret_bounds) {
  77     caret_bounds_ = caret_bounds;
  78   }
  79   void set_composition_character_bounds(
  80       const std::vector<gfx::Rect>& composition_character_bounds) {
  81     composition_character_bounds_ = composition_character_bounds;
  82   }
  83   void set_emulate_pepper_flash(bool enabled) {
  84     emulate_pepper_flash_ = enabled;
  85   }
  86
  87  private:
  88   // Overriden from DummyTextInputClient.
  89   virtual void SetCompositionText(
  90       const ui::CompositionText& composition) OVERRIDE {
  91     ++call_count_set_composition_text_;
  92   }
  93   virtual void InsertChar(base::char16 ch, int flags) OVERRIDE {
  94     inserted_text_.append(1, ch);
  95     ++call_count_insert_char_;
  96   }
  97   virtual void InsertText(const base::string16& text) OVERRIDE {
  98     inserted_text_.append(text);
  99     ++call_count_insert_text_;
 100   }
 101   virtual ui::TextInputType GetTextInputType() const OVERRIDE {
 102     return text_input_type_;
 103   }
 104   virtual ui::TextInputMode GetTextInputMode() const OVERRIDE {
 105     return text_input_mode_;
 106   }
 107   virtual gfx::Rect GetCaretBounds() const {
 108     return caret_bounds_;
 109   }
 110   virtual bool GetCompositionCharacterBounds(uint32 index,
 111                                              gfx::Rect* rect) const OVERRIDE {
 112     // Emulate the situation of crbug.com/328237.
 113     if (emulate_pepper_flash_)
 114       return false;
 115     if (!rect || composition_character_bounds_.size() <= index)
 116       return false;
 117     *rect = composition_character_bounds_[index];
 118     return true;
 119   }
 120   virtual bool HasCompositionText() const OVERRIDE {
 121     return !composition_character_bounds_.empty();
 122   }
 123   virtual bool GetCompositionTextRange(gfx::Range* range) const OVERRIDE {
 124     if (composition_character_bounds_.empty())
 125       return false;
 126     *range = gfx::Range(0, composition_character_bounds_.size());
 127     return true;
 128   }
 129   virtual void OnCandidateWindowShown() OVERRIDE {
 130     is_candidate_window_shown_called_ = true;
 131   }
 132   virtual void OnCandidateWindowHidden() OVERRIDE {
 133     is_candidate_window_hidden_called_ = true;
 134   }
 135
 136   ui::TextInputType text_input_type_;
 137   ui::TextInputMode text_input_mode_;
 138   gfx::Rect caret_bounds_;
 139   std::vector<gfx::Rect> composition_character_bounds_;
 140   base::string16 inserted_text_;
 141   size_t call_count_set_composition_text_;
 142   size_t call_count_insert_char_;
 143   size_t call_count_insert_text_;
 144   bool emulate_pepper_flash_;
 145   bool is_candidate_window_shown_called_;
 146   bool is_candidate_window_hidden_called_;
 147   DISALLOW_COPY_AND_ASSIGN(MockTextInputClient);
 148 };
 149
 150 class MockInputMethodDelegate : public internal::InputMethodDelegate {
 151  public:
 152   MockInputMethodDelegate() {}
 153
 154   const std::vector<ui::KeyboardCode>& fabricated_key_events() const {
 155     return fabricated_key_events_;
 156   }
 157   void Reset() {
 158     fabricated_key_events_.clear();
 159   }
 160
 161  private:
 162   virtual bool DispatchKeyEventPostIME(
 163       const base::NativeEvent& native_key_event) OVERRIDE {
 164     EXPECT_TRUE(false) << "Not reach here";
 165     return true;
 166   }
 167   virtual bool DispatchFabricatedKeyEventPostIME(ui::EventType type,
 168                                                  ui::KeyboardCode key_code,
 169                                                  int flags) OVERRIDE {
 170     fabricated_key_events_.push_back(key_code);
 171     return true;
 172   }
 173
 174   std::vector<ui::KeyboardCode> fabricated_key_events_;
 175   DISALLOW_COPY_AND_ASSIGN(MockInputMethodDelegate);
 176 };
 177
 178 class MockRemoteInputMethodDelegateWin
 179     : public internal::RemoteInputMethodDelegateWin {
 180  public:
 181   MockRemoteInputMethodDelegateWin()
 182       : cancel_composition_called_(false),
 183         text_input_client_updated_called_(false) {
 184   }
 185
 186   bool cancel_composition_called() const {
 187     return cancel_composition_called_;
 188   }
 189   bool text_input_client_updated_called() const {
 190     return text_input_client_updated_called_;
 191   }
 192   const std::vector<int32>& input_scopes() const {
 193     return input_scopes_;
 194   }
 195   const std::vector<gfx::Rect>& composition_character_bounds() const {
 196     return composition_character_bounds_;
 197   }
 198   void Reset() {
 199     cancel_composition_called_ = false;
 200     text_input_client_updated_called_ = false;
 201     input_scopes_.clear();
 202     composition_character_bounds_.clear();
 203   }
 204
 205  private:
 206   virtual void CancelComposition() OVERRIDE {
 207     cancel_composition_called_ = true;
 208   }
 209
 210   virtual void OnTextInputClientUpdated(
 211       const std::vector<int32>& input_scopes,
 212       const std::vector<gfx::Rect>& composition_character_bounds) OVERRIDE {
 213     text_input_client_updated_called_ = true;
 214     input_scopes_ = input_scopes;
 215     composition_character_bounds_ = composition_character_bounds;
 216   }
 217
 218   bool cancel_composition_called_;
 219   bool text_input_client_updated_called_;
 220   std::vector<int32> input_scopes_;
 221   std::vector<gfx::Rect> composition_character_bounds_;
 222   DISALLOW_COPY_AND_ASSIGN(MockRemoteInputMethodDelegateWin);
 223 };
 224
 225 class MockInputMethodObserver : public InputMethodObserver {
 226  public:
 227   MockInputMethodObserver()
 228       : on_text_input_state_changed_(0),
 229         on_input_method_destroyed_changed_(0) {
 230   }
 231   virtual ~MockInputMethodObserver() {
 232   }
 233   void Reset() {
 234     on_text_input_state_changed_ = 0;
 235     on_input_method_destroyed_changed_ = 0;
 236   }
 237   size_t on_text_input_state_changed() const {
 238     return on_text_input_state_changed_;
 239   }
 240   size_t on_input_method_destroyed_changed() const {
 241     return on_input_method_destroyed_changed_;
 242   }
 243
 244  private:
 245   // Overriden from InputMethodObserver.
 246   virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE {
 247   }
 248   virtual void OnFocus() OVERRIDE {
 249   }
 250   virtual void OnBlur() OVERRIDE {
 251   }
 252   virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE {
 253   }
 254   virtual void OnTextInputStateChanged(const TextInputClient* client) OVERRIDE {
 255     ++on_text_input_state_changed_;
 256   }
 257   virtual void OnInputMethodDestroyed(const InputMethod* client) OVERRIDE {
 258     ++on_input_method_destroyed_changed_;
 259   }
 260   virtual void OnShowImeIfNeeded() {
 261   }
 262
 263   size_t on_text_input_state_changed_;
 264   size_t on_input_method_destroyed_changed_;
 265   DISALLOW_COPY_AND_ASSIGN(MockInputMethodObserver);
 266 };
 267
 268 typedef ScopedObserver<InputMethod, InputMethodObserver>
 269     InputMethodScopedObserver;
 270
 271 TEST(RemoteInputMethodWinTest, RemoteInputMethodPrivateWin) {
 272   InputMethod* other_ptr = static_cast<InputMethod*>(NULL) + 1;
 273
 274   // Use typed NULL to make EXPECT_NE happy until nullptr becomes available.
 275   RemoteInputMethodPrivateWin* kNull =
 276       static_cast<RemoteInputMethodPrivateWin*>(NULL);
 277   EXPECT_EQ(kNull, RemoteInputMethodPrivateWin::Get(other_ptr));
 278
 279   MockInputMethodDelegate delegate_;
 280   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 281   EXPECT_NE(kNull, RemoteInputMethodPrivateWin::Get(input_method.get()));
 282
 283   InputMethod* dangling_ptr = input_method.get();
 284   input_method.reset(NULL);
 285   EXPECT_EQ(kNull, RemoteInputMethodPrivateWin::Get(dangling_ptr));
 286 }
 287
 288 TEST(RemoteInputMethodWinTest, OnInputSourceChanged) {
 289   MockInputMethodDelegate delegate_;
 290   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 291   RemoteInputMethodPrivateWin* private_ptr =
 292       RemoteInputMethodPrivateWin::Get(input_method.get());
 293   ASSERT_TRUE(private_ptr != NULL);
 294
 295   private_ptr->OnInputSourceChanged(
 296       MAKELANGID(LANG_JAPANESE, SUBLANG_JAPANESE_JAPAN), true);
 297   EXPECT_EQ("ja-JP", input_method->GetInputLocale());
 298
 299   private_ptr->OnInputSourceChanged(
 300       MAKELANGID(LANG_ARABIC, SUBLANG_ARABIC_QATAR), true);
 301   EXPECT_EQ("ar-QA", input_method->GetInputLocale());
 302 }
 303
 304 TEST(RemoteInputMethodWinTest, OnCandidatePopupChanged) {
 305   MockInputMethodDelegate delegate_;
 306   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 307   RemoteInputMethodPrivateWin* private_ptr =
 308       RemoteInputMethodPrivateWin::Get(input_method.get());
 309   ASSERT_TRUE(private_ptr != NULL);
 310
 311   // Initial value
 312   EXPECT_FALSE(input_method->IsCandidatePopupOpen());
 313
 314   // RemoteInputMethodWin::OnCandidatePopupChanged can be called even when the
 315   // focused text input client is NULL.
 316   ASSERT_TRUE(input_method->GetTextInputClient() == NULL);
 317   private_ptr->OnCandidatePopupChanged(false);
 318   private_ptr->OnCandidatePopupChanged(true);
 319
 320   MockTextInputClient mock_text_input_client;
 321   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 322
 323   ASSERT_FALSE(mock_text_input_client.is_candidate_window_shown_called());
 324   ASSERT_FALSE(mock_text_input_client.is_candidate_window_hidden_called());
 325   mock_text_input_client.Reset();
 326
 327   private_ptr->OnCandidatePopupChanged(true);
 328   EXPECT_TRUE(input_method->IsCandidatePopupOpen());
 329   EXPECT_TRUE(mock_text_input_client.is_candidate_window_shown_called());
 330   EXPECT_FALSE(mock_text_input_client.is_candidate_window_hidden_called());
 331
 332   private_ptr->OnCandidatePopupChanged(false);
 333   EXPECT_FALSE(input_method->IsCandidatePopupOpen());
 334   EXPECT_TRUE(mock_text_input_client.is_candidate_window_shown_called());
 335   EXPECT_TRUE(mock_text_input_client.is_candidate_window_hidden_called());
 336 }
 337
 338 TEST(RemoteInputMethodWinTest, CancelComposition) {
 339   MockInputMethodDelegate delegate_;
 340   MockTextInputClient mock_text_input_client;
 341   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 342
 343   // This must not cause a crash.
 344   input_method->CancelComposition(&mock_text_input_client);
 345
 346   RemoteInputMethodPrivateWin* private_ptr =
 347       RemoteInputMethodPrivateWin::Get(input_method.get());
 348   ASSERT_TRUE(private_ptr != NULL);
 349   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 350   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 351
 352   input_method->CancelComposition(&mock_text_input_client);
 353   EXPECT_FALSE(mock_remote_delegate.cancel_composition_called());
 354
 355   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 356   input_method->CancelComposition(&mock_text_input_client);
 357   EXPECT_TRUE(mock_remote_delegate.cancel_composition_called());
 358 }
 359
 360 TEST(RemoteInputMethodWinTest, SetFocusedTextInputClient) {
 361   MockInputMethodDelegate delegate_;
 362   MockTextInputClient mock_text_input_client;
 363   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 364
 365   mock_text_input_client.set_caret_bounds(gfx::Rect(10, 0, 10, 20));
 366   mock_text_input_client.set_text_input_type(ui::TEXT_INPUT_TYPE_URL);
 367   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 368
 369   RemoteInputMethodPrivateWin* private_ptr =
 370       RemoteInputMethodPrivateWin::Get(input_method.get());
 371   ASSERT_TRUE(private_ptr != NULL);
 372   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 373   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 374
 375   // Initial state must be synced.
 376   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 377   ASSERT_EQ(1, mock_remote_delegate.composition_character_bounds().size());
 378   EXPECT_EQ(gfx::Rect(10, 0, 10, 20),
 379             mock_remote_delegate.composition_character_bounds()[0]);
 380   ASSERT_EQ(1, mock_remote_delegate.input_scopes().size());
 381   EXPECT_EQ(IS_URL, mock_remote_delegate.input_scopes()[0]);
 382
 383   // State must be cleared by SetFocusedTextInputClient(NULL).
 384   mock_remote_delegate.Reset();
 385   input_method->SetFocusedTextInputClient(NULL);
 386   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 387   EXPECT_TRUE(mock_remote_delegate.composition_character_bounds().empty());
 388   EXPECT_TRUE(mock_remote_delegate.input_scopes().empty());
 389 }
 390
 391 TEST(RemoteInputMethodWinTest, DetachTextInputClient) {
 392   MockInputMethodDelegate delegate_;
 393   MockTextInputClient mock_text_input_client;
 394   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 395
 396   mock_text_input_client.set_caret_bounds(gfx::Rect(10, 0, 10, 20));
 397   mock_text_input_client.set_text_input_type(ui::TEXT_INPUT_TYPE_URL);
 398   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 399
 400   RemoteInputMethodPrivateWin* private_ptr =
 401       RemoteInputMethodPrivateWin::Get(input_method.get());
 402   ASSERT_TRUE(private_ptr != NULL);
 403   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 404   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 405
 406   // Initial state must be synced.
 407   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 408   ASSERT_EQ(1, mock_remote_delegate.composition_character_bounds().size());
 409   EXPECT_EQ(gfx::Rect(10, 0, 10, 20),
 410     mock_remote_delegate.composition_character_bounds()[0]);
 411   ASSERT_EQ(1, mock_remote_delegate.input_scopes().size());
 412   EXPECT_EQ(IS_URL, mock_remote_delegate.input_scopes()[0]);
 413
 414   // State must be cleared by DetachTextInputClient
 415   mock_remote_delegate.Reset();
 416   input_method->DetachTextInputClient(&mock_text_input_client);
 417   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 418   EXPECT_TRUE(mock_remote_delegate.composition_character_bounds().empty());
 419   EXPECT_TRUE(mock_remote_delegate.input_scopes().empty());
 420 }
 421
 422 TEST(RemoteInputMethodWinTest, OnCaretBoundsChanged) {
 423   MockInputMethodDelegate delegate_;
 424   MockTextInputClient mock_text_input_client;
 425   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 426
 427   // This must not cause a crash.
 428   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 429
 430   mock_text_input_client.set_caret_bounds(gfx::Rect(10, 0, 10, 20));
 431   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 432
 433   RemoteInputMethodPrivateWin* private_ptr =
 434       RemoteInputMethodPrivateWin::Get(input_method.get());
 435   ASSERT_TRUE(private_ptr != NULL);
 436   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 437   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 438
 439   // Initial state must be synced.
 440   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 441   ASSERT_EQ(1, mock_remote_delegate.composition_character_bounds().size());
 442   EXPECT_EQ(gfx::Rect(10, 0, 10, 20),
 443       mock_remote_delegate.composition_character_bounds()[0]);
 444
 445   // Redundant OnCaretBoundsChanged must be ignored.
 446   mock_remote_delegate.Reset();
 447   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 448   EXPECT_FALSE(mock_remote_delegate.text_input_client_updated_called());
 449
 450   // Check OnCaretBoundsChanged is handled. (w/o composition)
 451   mock_remote_delegate.Reset();
 452   mock_text_input_client.Reset();
 453   mock_text_input_client.set_caret_bounds(gfx::Rect(10, 20, 30, 40));
 454   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 455   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 456   ASSERT_EQ(1, mock_remote_delegate.composition_character_bounds().size());
 457   EXPECT_EQ(gfx::Rect(10, 20, 30, 40),
 458       mock_remote_delegate.composition_character_bounds()[0]);
 459
 460   // Check OnCaretBoundsChanged is handled. (w/ composition)
 461   {
 462     mock_remote_delegate.Reset();
 463     mock_text_input_client.Reset();
 464
 465     std::vector<gfx::Rect> bounds;
 466     bounds.push_back(gfx::Rect(10, 20, 30, 40));
 467     bounds.push_back(gfx::Rect(40, 30, 20, 10));
 468     mock_text_input_client.set_composition_character_bounds(bounds);
 469     input_method->OnCaretBoundsChanged(&mock_text_input_client);
 470     EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 471     EXPECT_EQ(bounds, mock_remote_delegate.composition_character_bounds());
 472   }
 473 }
 474
 475 // Test case against crbug.com/328237.
 476 TEST(RemoteInputMethodWinTest, OnCaretBoundsChangedForPepperFlash) {
 477   MockInputMethodDelegate delegate_;
 478   MockTextInputClient mock_text_input_client;
 479   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 480   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 481
 482   RemoteInputMethodPrivateWin* private_ptr =
 483       RemoteInputMethodPrivateWin::Get(input_method.get());
 484   ASSERT_TRUE(private_ptr != NULL);
 485   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 486   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 487
 488   mock_remote_delegate.Reset();
 489   mock_text_input_client.Reset();
 490   mock_text_input_client.set_emulate_pepper_flash(true);
 491
 492   std::vector<gfx::Rect> caret_bounds;
 493   caret_bounds.push_back(gfx::Rect(5, 15, 25, 35));
 494   mock_text_input_client.set_caret_bounds(caret_bounds[0]);
 495
 496   std::vector<gfx::Rect> composition_bounds;
 497   composition_bounds.push_back(gfx::Rect(10, 20, 30, 40));
 498   composition_bounds.push_back(gfx::Rect(40, 30, 20, 10));
 499   mock_text_input_client.set_composition_character_bounds(composition_bounds);
 500   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 501   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 502   // The caret bounds must be used when
 503   // TextInputClient::GetCompositionCharacterBounds failed.
 504   EXPECT_EQ(caret_bounds, mock_remote_delegate.composition_character_bounds());
 505 }
 506
 507 TEST(RemoteInputMethodWinTest, OnTextInputTypeChanged) {
 508   MockInputMethodDelegate delegate_;
 509   MockTextInputClient mock_text_input_client;
 510   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 511
 512   // This must not cause a crash.
 513   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 514
 515   mock_text_input_client.set_text_input_type(ui::TEXT_INPUT_TYPE_URL);
 516   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 517
 518   RemoteInputMethodPrivateWin* private_ptr =
 519       RemoteInputMethodPrivateWin::Get(input_method.get());
 520   ASSERT_TRUE(private_ptr != NULL);
 521   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 522   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 523
 524   // Initial state must be synced.
 525   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 526   ASSERT_EQ(1, mock_remote_delegate.input_scopes().size());
 527   EXPECT_EQ(IS_URL, mock_remote_delegate.input_scopes()[0]);
 528
 529   // Check TEXT_INPUT_TYPE_NONE is handled.
 530   mock_remote_delegate.Reset();
 531   mock_text_input_client.Reset();
 532   mock_text_input_client.set_text_input_type(ui::TEXT_INPUT_TYPE_NONE);
 533   mock_text_input_client.set_text_input_mode(ui::TEXT_INPUT_MODE_KATAKANA);
 534   input_method->OnTextInputTypeChanged(&mock_text_input_client);
 535   EXPECT_TRUE(mock_remote_delegate.text_input_client_updated_called());
 536   EXPECT_TRUE(mock_remote_delegate.input_scopes().empty());
 537
 538   // Redundant OnTextInputTypeChanged must be ignored.
 539   mock_remote_delegate.Reset();
 540   input_method->OnTextInputTypeChanged(&mock_text_input_client);
 541   EXPECT_FALSE(mock_remote_delegate.text_input_client_updated_called());
 542
 543   mock_remote_delegate.Reset();
 544   mock_text_input_client.Reset();
 545   mock_text_input_client.set_caret_bounds(gfx::Rect(10, 20, 30, 40));
 546   input_method->OnCaretBoundsChanged(&mock_text_input_client);
 547 }
 548
 549 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_NativeKeyEvent) {
 550   // Basically RemoteInputMethodWin does not handle native keydown event.
 551
 552   MockInputMethodDelegate delegate_;
 553   MockTextInputClient mock_text_input_client;
 554   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 555
 556   const MSG wm_keydown = { NULL, WM_KEYDOWN, ui::VKEY_A };
 557   ui::KeyEvent native_keydown(wm_keydown, false);
 558
 559   // This must not cause a crash.
 560   EXPECT_FALSE(input_method->DispatchKeyEvent(native_keydown));
 561   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 562   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 563   delegate_.Reset();
 564   mock_text_input_client.Reset();
 565
 566   RemoteInputMethodPrivateWin* private_ptr =
 567       RemoteInputMethodPrivateWin::Get(input_method.get());
 568   ASSERT_TRUE(private_ptr != NULL);
 569   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 570   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 571
 572   // TextInputClient is not focused yet here.
 573
 574   EXPECT_FALSE(input_method->DispatchKeyEvent(native_keydown));
 575   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 576   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 577   delegate_.Reset();
 578   mock_text_input_client.Reset();
 579
 580   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 581
 582   // TextInputClient is now focused here.
 583
 584   EXPECT_FALSE(input_method->DispatchKeyEvent(native_keydown));
 585   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 586   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 587   delegate_.Reset();
 588   mock_text_input_client.Reset();
 589 }
 590
 591 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_NativeCharEvent) {
 592   // RemoteInputMethodWin handles native char event if possible.
 593
 594   MockInputMethodDelegate delegate_;
 595   MockTextInputClient mock_text_input_client;
 596   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 597
 598   const MSG wm_char = { NULL, WM_CHAR, 'A', 0 };
 599   ui::KeyEvent native_char(wm_char, true);
 600
 601   // This must not cause a crash.
 602   EXPECT_FALSE(input_method->DispatchKeyEvent(native_char));
 603   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 604   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 605   delegate_.Reset();
 606   mock_text_input_client.Reset();
 607
 608   RemoteInputMethodPrivateWin* private_ptr =
 609       RemoteInputMethodPrivateWin::Get(input_method.get());
 610   ASSERT_TRUE(private_ptr != NULL);
 611   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 612   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 613
 614   // TextInputClient is not focused yet here.
 615
 616   EXPECT_FALSE(input_method->DispatchKeyEvent(native_char));
 617   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 618   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 619   delegate_.Reset();
 620   mock_text_input_client.Reset();
 621
 622   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 623
 624   // TextInputClient is now focused here.
 625
 626   EXPECT_TRUE(input_method->DispatchKeyEvent(native_char));
 627   EXPECT_EQ(L"A", mock_text_input_client.inserted_text());
 628   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 629   delegate_.Reset();
 630   mock_text_input_client.Reset();
 631 }
 632
 633 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_FabricatedKeyDown) {
 634   // Fabricated non-char event will be delegated to
 635   // InputMethodDelegate::DispatchFabricatedKeyEventPostIME as long as the
 636   // delegate is installed.
 637
 638   MockInputMethodDelegate delegate_;
 639   MockTextInputClient mock_text_input_client;
 640   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 641
 642   ui::KeyEvent fabricated_keydown(ui::ET_KEY_PRESSED, ui::VKEY_A, 0, false);
 643   fabricated_keydown.set_character(L'A');
 644
 645   // This must not cause a crash.
 646   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_keydown));
 647   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 648   ASSERT_EQ(1, delegate_.fabricated_key_events().size());
 649   EXPECT_EQ(L'A', delegate_.fabricated_key_events()[0]);
 650   delegate_.Reset();
 651   mock_text_input_client.Reset();
 652
 653   RemoteInputMethodPrivateWin* private_ptr =
 654       RemoteInputMethodPrivateWin::Get(input_method.get());
 655   ASSERT_TRUE(private_ptr != NULL);
 656   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 657   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 658
 659   // TextInputClient is not focused yet here.
 660
 661   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_keydown));
 662   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 663   ASSERT_EQ(1, delegate_.fabricated_key_events().size());
 664   EXPECT_EQ(L'A', delegate_.fabricated_key_events()[0]);
 665   delegate_.Reset();
 666   mock_text_input_client.Reset();
 667
 668   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 669   // TextInputClient is now focused here.
 670
 671   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_keydown));
 672   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 673   ASSERT_EQ(1, delegate_.fabricated_key_events().size());
 674   EXPECT_EQ(L'A', delegate_.fabricated_key_events()[0]);
 675   delegate_.Reset();
 676   mock_text_input_client.Reset();
 677
 678   input_method->SetDelegate(NULL);
 679   // RemoteInputMethodDelegateWin is no longer set here.
 680
 681   EXPECT_FALSE(input_method->DispatchKeyEvent(fabricated_keydown));
 682   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 683 }
 684
 685 TEST(RemoteInputMethodWinTest, DispatchKeyEvent_FabricatedChar) {
 686   // Note: RemoteInputMethodWin::DispatchKeyEvent should always return true
 687   // for fabricated character events.
 688
 689   MockInputMethodDelegate delegate_;
 690   MockTextInputClient mock_text_input_client;
 691   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 692
 693   ui::KeyEvent fabricated_char(ui::ET_KEY_PRESSED, ui::VKEY_A, 0, true);
 694   fabricated_char.set_character(L'A');
 695
 696   // This must not cause a crash.
 697   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
 698   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 699   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 700   delegate_.Reset();
 701   mock_text_input_client.Reset();
 702
 703   RemoteInputMethodPrivateWin* private_ptr =
 704       RemoteInputMethodPrivateWin::Get(input_method.get());
 705   ASSERT_TRUE(private_ptr != NULL);
 706   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 707   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 708
 709   // TextInputClient is not focused yet here.
 710
 711   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
 712   EXPECT_TRUE(mock_text_input_client.inserted_text().empty());
 713   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 714   delegate_.Reset();
 715   mock_text_input_client.Reset();
 716
 717   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 718
 719   // TextInputClient is now focused here.
 720
 721   EXPECT_TRUE(input_method->DispatchKeyEvent(fabricated_char));
 722   EXPECT_EQ(L"A", mock_text_input_client.inserted_text());
 723   EXPECT_TRUE(delegate_.fabricated_key_events().empty());
 724   delegate_.Reset();
 725   mock_text_input_client.Reset();
 726 }
 727
 728 TEST(RemoteInputMethodWinTest, OnCompositionChanged) {
 729   MockInputMethodDelegate delegate_;
 730   MockTextInputClient mock_text_input_client;
 731   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 732
 733   RemoteInputMethodPrivateWin* private_ptr =
 734       RemoteInputMethodPrivateWin::Get(input_method.get());
 735   ASSERT_TRUE(private_ptr != NULL);
 736   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 737   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 738
 739   CompositionText composition_text;
 740
 741   // TextInputClient is not focused yet here.
 742
 743   private_ptr->OnCompositionChanged(composition_text);
 744   EXPECT_EQ(0, mock_text_input_client.call_count_set_composition_text());
 745   delegate_.Reset();
 746   mock_text_input_client.Reset();
 747
 748   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 749
 750   // TextInputClient is now focused here.
 751
 752   private_ptr->OnCompositionChanged(composition_text);
 753   EXPECT_EQ(1, mock_text_input_client.call_count_set_composition_text());
 754   delegate_.Reset();
 755   mock_text_input_client.Reset();
 756 }
 757
 758 TEST(RemoteInputMethodWinTest, OnTextCommitted) {
 759   MockInputMethodDelegate delegate_;
 760   MockTextInputClient mock_text_input_client;
 761   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 762
 763   RemoteInputMethodPrivateWin* private_ptr =
 764       RemoteInputMethodPrivateWin::Get(input_method.get());
 765   ASSERT_TRUE(private_ptr != NULL);
 766   MockRemoteInputMethodDelegateWin mock_remote_delegate;
 767   private_ptr->SetRemoteDelegate(&mock_remote_delegate);
 768
 769   base::string16 committed_text = L"Hello";
 770
 771   // TextInputClient is not focused yet here.
 772
 773   mock_text_input_client.set_text_input_type(TEXT_INPUT_TYPE_TEXT);
 774   private_ptr->OnTextCommitted(committed_text);
 775   EXPECT_EQ(0, mock_text_input_client.call_count_insert_char());
 776   EXPECT_EQ(0, mock_text_input_client.call_count_insert_text());
 777   EXPECT_EQ(L"", mock_text_input_client.inserted_text());
 778   delegate_.Reset();
 779   mock_text_input_client.Reset();
 780
 781   input_method->SetFocusedTextInputClient(&mock_text_input_client);
 782
 783   // TextInputClient is now focused here.
 784
 785   mock_text_input_client.set_text_input_type(TEXT_INPUT_TYPE_TEXT);
 786   private_ptr->OnTextCommitted(committed_text);
 787   EXPECT_EQ(0, mock_text_input_client.call_count_insert_char());
 788   EXPECT_EQ(1, mock_text_input_client.call_count_insert_text());
 789   EXPECT_EQ(committed_text, mock_text_input_client.inserted_text());
 790   delegate_.Reset();
 791   mock_text_input_client.Reset();
 792
 793   // When TextInputType is TEXT_INPUT_TYPE_NONE, TextInputClient::InsertText
 794   // should not be used.
 795   mock_text_input_client.set_text_input_type(TEXT_INPUT_TYPE_NONE);
 796   private_ptr->OnTextCommitted(committed_text);
 797   EXPECT_EQ(committed_text.size(),
 798             mock_text_input_client.call_count_insert_char());
 799   EXPECT_EQ(0, mock_text_input_client.call_count_insert_text());
 800   EXPECT_EQ(committed_text, mock_text_input_client.inserted_text());
 801   delegate_.Reset();
 802   mock_text_input_client.Reset();
 803 }
 804
 805 TEST(RemoteInputMethodWinTest, OnTextInputStateChanged_Observer) {
 806   DummyTextInputClient text_input_client;
 807   DummyTextInputClient text_input_client_the_other;
 808
 809   MockInputMethodObserver input_method_observer;
 810   MockInputMethodDelegate delegate_;
 811   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 812   InputMethodScopedObserver scoped_observer(&input_method_observer);
 813   scoped_observer.Add(input_method.get());
 814
 815   input_method->SetFocusedTextInputClient(&text_input_client);
 816   ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
 817   EXPECT_EQ(1u, input_method_observer.on_text_input_state_changed());
 818   input_method_observer.Reset();
 819
 820   input_method->SetFocusedTextInputClient(&text_input_client);
 821   ASSERT_EQ(&text_input_client, input_method->GetTextInputClient());
 822   EXPECT_EQ(0u, input_method_observer.on_text_input_state_changed());
 823   input_method_observer.Reset();
 824
 825   input_method->SetFocusedTextInputClient(&text_input_client_the_other);
 826   ASSERT_EQ(&text_input_client_the_other, input_method->GetTextInputClient());
 827   EXPECT_EQ(1u, input_method_observer.on_text_input_state_changed());
 828   input_method_observer.Reset();
 829
 830   input_method->DetachTextInputClient(&text_input_client_the_other);
 831   ASSERT_TRUE(input_method->GetTextInputClient() == NULL);
 832   EXPECT_EQ(1u, input_method_observer.on_text_input_state_changed());
 833   input_method_observer.Reset();
 834 }
 835
 836 TEST(RemoteInputMethodWinTest, OnInputMethodDestroyed_Observer) {
 837   DummyTextInputClient text_input_client;
 838   DummyTextInputClient text_input_client_the_other;
 839
 840   MockInputMethodObserver input_method_observer;
 841   InputMethodScopedObserver scoped_observer(&input_method_observer);
 842
 843   MockInputMethodDelegate delegate_;
 844   scoped_ptr<InputMethod> input_method(CreateRemoteInputMethodWin(&delegate_));
 845   input_method->AddObserver(&input_method_observer);
 846
 847   EXPECT_EQ(0u, input_method_observer.on_input_method_destroyed_changed());
 848   input_method.reset();
 849   EXPECT_EQ(1u, input_method_observer.on_input_method_destroyed_changed());
 850 }
 851
 852 }  // namespace
 853 }  // namespace ui