Home | History | Annotate | Download | only in ime 
      1 // Copyright 2014 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_chromeos.h"
      6 
      7 #include <X11/Xlib.h>
      8 #undef Bool
      9 #undef FocusIn
     10 #undef FocusOut
     11 #undef None
     12 
     13 #include <cstring>
     14 
     15 #include "base/i18n/char_iterator.h"
     16 #include "base/memory/scoped_ptr.h"
     17 #include "base/strings/utf_string_conversions.h"
     18 #include "chromeos/ime/composition_text.h"
     19 #include "testing/gtest/include/gtest/gtest.h"
     20 #include "ui/base/ime/chromeos/ime_bridge.h"
     21 #include "ui/base/ime/chromeos/mock_ime_candidate_window_handler.h"
     22 #include "ui/base/ime/chromeos/mock_ime_engine_handler.h"
     23 #include "ui/base/ime/input_method_delegate.h"
     24 #include "ui/base/ime/text_input_client.h"
     25 #include "ui/base/ime/text_input_focus_manager.h"
     26 #include "ui/base/ui_base_switches_util.h"
     27 #include "ui/events/event.h"
     28 #include "ui/events/test/events_test_utils_x11.h"
     29 #include "ui/gfx/geometry/rect.h"
     30 
     31 using base::UTF8ToUTF16;
     32 using base::UTF16ToUTF8;
     33 
     34 namespace ui {
     35 namespace {
     36 
     37 const base::string16 kSampleText = base::UTF8ToUTF16(
     38     "\xE3\x81\x82\xE3\x81\x84\xE3\x81\x86\xE3\x81\x88\xE3\x81\x8A");
     39 
     40 typedef chromeos::IMEEngineHandlerInterface::KeyEventDoneCallback
     41     KeyEventCallback;
     42 
     43 uint32 GetOffsetInUTF16(
     44     const base::string16& utf16_string, uint32 utf8_offset) {
     45   DCHECK_LT(utf8_offset, utf16_string.size());
     46   base::i18n::UTF16CharIterator char_iterator(&utf16_string);
     47   for (size_t i = 0; i < utf8_offset; ++i)
     48     char_iterator.Advance();
     49   return char_iterator.array_pos();
     50 }
     51 
     52 bool IsEqualXKeyEvent(const XEvent& e1, const XEvent& e2) {
     53   if ((e1.type == KeyPress && e2.type == KeyPress) ||
     54       (e1.type == KeyRelease && e2.type == KeyRelease)) {
     55     return !std::memcmp(&e1.xkey, &e2.xkey, sizeof(XKeyEvent));
     56   }
     57   return false;
     58 }
     59 
     60 enum KeyEventHandlerBehavior {
     61   KEYEVENT_CONSUME,
     62   KEYEVENT_NOT_CONSUME,
     63 };
     64 
     65 }  // namespace
     66 
     67 
     68 class TestableInputMethodChromeOS : public InputMethodChromeOS {
     69  public:
     70   explicit TestableInputMethodChromeOS(internal::InputMethodDelegate* delegate)
     71       : InputMethodChromeOS(delegate),
     72         process_key_event_post_ime_call_count_(0) {
     73   }
     74 
     75   struct ProcessKeyEventPostIMEArgs {
     76     ProcessKeyEventPostIMEArgs() : event(NULL), handled(false) {}
     77     const ui::KeyEvent* event;
     78     bool handled;
     79   };
     80 
     81   // Overridden from InputMethodChromeOS:
     82   virtual void ProcessKeyEventPostIME(const ui::KeyEvent& key_event,
     83                                       bool handled) OVERRIDE {
     84     process_key_event_post_ime_args_.event = &key_event;
     85     process_key_event_post_ime_args_.handled = handled;
     86     ++process_key_event_post_ime_call_count_;
     87   }
     88 
     89   void ResetCallCount() {
     90     process_key_event_post_ime_call_count_ = 0;
     91   }
     92 
     93   const ProcessKeyEventPostIMEArgs& process_key_event_post_ime_args() const {
     94     return process_key_event_post_ime_args_;
     95   }
     96 
     97   int process_key_event_post_ime_call_count() const {
     98     return process_key_event_post_ime_call_count_;
     99   }
    100 
    101   // Change access rights for testing.
    102   using InputMethodChromeOS::ExtractCompositionText;
    103   using InputMethodChromeOS::ResetContext;
    104 
    105  private:
    106   ProcessKeyEventPostIMEArgs process_key_event_post_ime_args_;
    107   int process_key_event_post_ime_call_count_;
    108 };
    109 
    110 class SynchronousKeyEventHandler {
    111  public:
    112   SynchronousKeyEventHandler(uint32 expected_keyval,
    113                              uint32 expected_keycode,
    114                              uint32 expected_state,
    115                              KeyEventHandlerBehavior behavior)
    116       : expected_keyval_(expected_keyval),
    117         expected_keycode_(expected_keycode),
    118         expected_state_(expected_state),
    119         behavior_(behavior) {}
    120 
    121   virtual ~SynchronousKeyEventHandler() {}
    122 
    123   void Run(uint32 keyval,
    124            uint32 keycode,
    125            uint32 state,
    126            const KeyEventCallback& callback) {
    127     EXPECT_EQ(expected_keyval_, keyval);
    128     EXPECT_EQ(expected_keycode_, keycode);
    129     EXPECT_EQ(expected_state_, state);
    130     callback.Run(behavior_ == KEYEVENT_CONSUME);
    131   }
    132 
    133  private:
    134   const uint32 expected_keyval_;
    135   const uint32 expected_keycode_;
    136   const uint32 expected_state_;
    137   const KeyEventHandlerBehavior behavior_;
    138 
    139   DISALLOW_COPY_AND_ASSIGN(SynchronousKeyEventHandler);
    140 };
    141 
    142 class AsynchronousKeyEventHandler {
    143  public:
    144   AsynchronousKeyEventHandler(uint32 expected_keyval,
    145                               uint32 expected_keycode,
    146                               uint32 expected_state)
    147       : expected_keyval_(expected_keyval),
    148         expected_keycode_(expected_keycode),
    149         expected_state_(expected_state) {}
    150 
    151   virtual ~AsynchronousKeyEventHandler() {}
    152 
    153   void Run(uint32 keyval,
    154            uint32 keycode,
    155            uint32 state,
    156            const KeyEventCallback& callback) {
    157     EXPECT_EQ(expected_keyval_, keyval);
    158     EXPECT_EQ(expected_keycode_, keycode);
    159     EXPECT_EQ(expected_state_, state);
    160     callback_ = callback;
    161   }
    162 
    163   void RunCallback(KeyEventHandlerBehavior behavior) {
    164     callback_.Run(behavior == KEYEVENT_CONSUME);
    165   }
    166 
    167  private:
    168   const uint32 expected_keyval_;
    169   const uint32 expected_keycode_;
    170   const uint32 expected_state_;
    171   KeyEventCallback callback_;
    172 
    173   DISALLOW_COPY_AND_ASSIGN(AsynchronousKeyEventHandler);
    174 };
    175 
    176 class SetSurroundingTextVerifier {
    177  public:
    178   SetSurroundingTextVerifier(const std::string& expected_surrounding_text,
    179                              uint32 expected_cursor_position,
    180                              uint32 expected_anchor_position)
    181       : expected_surrounding_text_(expected_surrounding_text),
    182         expected_cursor_position_(expected_cursor_position),
    183         expected_anchor_position_(expected_anchor_position) {}
    184 
    185   void Verify(const std::string& text,
    186               uint32 cursor_pos,
    187               uint32 anchor_pos) {
    188     EXPECT_EQ(expected_surrounding_text_, text);
    189     EXPECT_EQ(expected_cursor_position_, cursor_pos);
    190     EXPECT_EQ(expected_anchor_position_, anchor_pos);
    191   }
    192 
    193  private:
    194   const std::string expected_surrounding_text_;
    195   const uint32 expected_cursor_position_;
    196   const uint32 expected_anchor_position_;
    197 
    198   DISALLOW_COPY_AND_ASSIGN(SetSurroundingTextVerifier);
    199 };
    200 
    201 class InputMethodChromeOSTest : public internal::InputMethodDelegate,
    202                                 public testing::Test,
    203                                 public TextInputClient {
    204  public:
    205   InputMethodChromeOSTest()
    206       : dispatched_key_event_(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, ui::EF_NONE) {
    207     ResetFlags();
    208   }
    209 
    210   virtual ~InputMethodChromeOSTest() {
    211   }
    212 
    213   virtual void SetUp() OVERRIDE {
    214     chromeos::IMEBridge::Initialize();
    215 
    216     mock_ime_engine_handler_.reset(
    217         new chromeos::MockIMEEngineHandler());
    218     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(
    219         mock_ime_engine_handler_.get());
    220 
    221     mock_ime_candidate_window_handler_.reset(
    222         new chromeos::MockIMECandidateWindowHandler());
    223     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(
    224         mock_ime_candidate_window_handler_.get());
    225 
    226     ime_.reset(new TestableInputMethodChromeOS(this));
    227     if (switches::IsTextInputFocusManagerEnabled())
    228       TextInputFocusManager::GetInstance()->FocusTextInputClient(this);
    229     else
    230       ime_->SetFocusedTextInputClient(this);
    231   }
    232 
    233   virtual void TearDown() OVERRIDE {
    234     if (ime_.get()) {
    235       if (switches::IsTextInputFocusManagerEnabled())
    236         TextInputFocusManager::GetInstance()->BlurTextInputClient(this);
    237       else
    238         ime_->SetFocusedTextInputClient(NULL);
    239     }
    240     ime_.reset();
    241     chromeos::IMEBridge::Get()->SetCurrentEngineHandler(NULL);
    242     chromeos::IMEBridge::Get()->SetCandidateWindowHandler(NULL);
    243     mock_ime_engine_handler_.reset();
    244     mock_ime_candidate_window_handler_.reset();
    245     chromeos::IMEBridge::Shutdown();
    246   }
    247 
    248   // Overridden from ui::internal::InputMethodDelegate:
    249   virtual bool DispatchKeyEventPostIME(const ui::KeyEvent& event) OVERRIDE {
    250     dispatched_key_event_ = event;
    251     return false;
    252   }
    253 
    254   // Overridden from ui::TextInputClient:
    255   virtual void SetCompositionText(
    256       const CompositionText& composition) OVERRIDE {
    257     composition_text_ = composition;
    258   }
    259   virtual void ConfirmCompositionText() OVERRIDE {
    260     confirmed_text_ = composition_text_;
    261     composition_text_.Clear();
    262   }
    263   virtual void ClearCompositionText() OVERRIDE {
    264     composition_text_.Clear();
    265   }
    266   virtual void InsertText(const base::string16& text) OVERRIDE {
    267     inserted_text_ = text;
    268   }
    269   virtual void InsertChar(base::char16 ch, int flags) OVERRIDE {
    270     inserted_char_ = ch;
    271     inserted_char_flags_ = flags;
    272   }
    273   virtual gfx::NativeWindow GetAttachedWindow() const OVERRIDE {
    274     return static_cast<gfx::NativeWindow>(NULL);
    275   }
    276   virtual TextInputType GetTextInputType() const OVERRIDE {
    277     return input_type_;
    278   }
    279   virtual TextInputMode GetTextInputMode() const OVERRIDE {
    280     return input_mode_;
    281   }
    282   virtual bool CanComposeInline() const OVERRIDE {
    283     return can_compose_inline_;
    284   }
    285   virtual gfx::Rect GetCaretBounds() const OVERRIDE {
    286     return caret_bounds_;
    287   }
    288   virtual bool GetCompositionCharacterBounds(uint32 index,
    289                                              gfx::Rect* rect) const OVERRIDE {
    290     return false;
    291   }
    292   virtual bool HasCompositionText() const OVERRIDE {
    293     CompositionText empty;
    294     return composition_text_ != empty;
    295   }
    296   virtual bool GetTextRange(gfx::Range* range) const OVERRIDE {
    297     *range = text_range_;
    298     return true;
    299   }
    300   virtual bool GetCompositionTextRange(gfx::Range* range) const OVERRIDE {
    301     return false;
    302   }
    303   virtual bool GetSelectionRange(gfx::Range* range) const OVERRIDE {
    304     *range = selection_range_;
    305     return true;
    306   }
    307 
    308   virtual bool SetSelectionRange(const gfx::Range& range) OVERRIDE {
    309     return false;
    310   }
    311   virtual bool DeleteRange(const gfx::Range& range) OVERRIDE { return false; }
    312   virtual bool GetTextFromRange(const gfx::Range& range,
    313                                 base::string16* text) const OVERRIDE {
    314     *text = surrounding_text_.substr(range.GetMin(), range.length());
    315     return true;
    316   }
    317   virtual void OnInputMethodChanged() OVERRIDE {
    318     ++on_input_method_changed_call_count_;
    319   }
    320   virtual bool ChangeTextDirectionAndLayoutAlignment(
    321       base::i18n::TextDirection direction) OVERRIDE { return false; }
    322   virtual void ExtendSelectionAndDelete(size_t before,
    323                                         size_t after) OVERRIDE {}
    324   virtual void EnsureCaretInRect(const gfx::Rect& rect) OVERRIDE {}
    325   virtual void OnCandidateWindowShown() OVERRIDE {}
    326   virtual void OnCandidateWindowUpdated() OVERRIDE {}
    327   virtual void OnCandidateWindowHidden() OVERRIDE {}
    328   virtual bool IsEditingCommandEnabled(int command_id) OVERRIDE {
    329     return false;
    330   }
    331   virtual void ExecuteEditingCommand(int command_id) OVERRIDE {}
    332 
    333   bool HasNativeEvent() const {
    334     return dispatched_key_event_.HasNativeEvent();
    335   }
    336 
    337   void ResetFlags() {
    338     dispatched_key_event_ = ui::KeyEvent(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN,
    339                                          ui::EF_NONE);
    340 
    341     composition_text_.Clear();
    342     confirmed_text_.Clear();
    343     inserted_text_.clear();
    344     inserted_char_ = 0;
    345     inserted_char_flags_ = 0;
    346     on_input_method_changed_call_count_ = 0;
    347 
    348     input_type_ = TEXT_INPUT_TYPE_NONE;
    349     input_mode_ = TEXT_INPUT_MODE_DEFAULT;
    350     can_compose_inline_ = true;
    351     caret_bounds_ = gfx::Rect();
    352   }
    353 
    354   scoped_ptr<TestableInputMethodChromeOS> ime_;
    355 
    356   // Copy of the dispatched key event.
    357   ui::KeyEvent dispatched_key_event_;
    358 
    359   // Variables for remembering the parameters that are passed to
    360   // ui::TextInputClient functions.
    361   CompositionText composition_text_;
    362   CompositionText confirmed_text_;
    363   base::string16 inserted_text_;
    364   base::char16 inserted_char_;
    365   unsigned int on_input_method_changed_call_count_;
    366   int inserted_char_flags_;
    367 
    368   // Variables that will be returned from the ui::TextInputClient functions.
    369   TextInputType input_type_;
    370   TextInputMode input_mode_;
    371   bool can_compose_inline_;
    372   gfx::Rect caret_bounds_;
    373   gfx::Range text_range_;
    374   gfx::Range selection_range_;
    375   base::string16 surrounding_text_;
    376 
    377   scoped_ptr<chromeos::MockIMEEngineHandler> mock_ime_engine_handler_;
    378   scoped_ptr<chromeos::MockIMECandidateWindowHandler>
    379       mock_ime_candidate_window_handler_;
    380 
    381   DISALLOW_COPY_AND_ASSIGN(InputMethodChromeOSTest);
    382 };
    383 
    384 // Tests public APIs in ui::InputMethod first.
    385 
    386 TEST_F(InputMethodChromeOSTest, GetInputLocale) {
    387   // ui::InputMethodChromeOS does not support the API.
    388   ime_->Init(true);
    389   EXPECT_EQ("", ime_->GetInputLocale());
    390 }
    391 
    392 TEST_F(InputMethodChromeOSTest, IsActive) {
    393   ime_->Init(true);
    394   // ui::InputMethodChromeOS always returns true.
    395   EXPECT_TRUE(ime_->IsActive());
    396 }
    397 
    398 TEST_F(InputMethodChromeOSTest, GetInputTextType) {
    399   ime_->Init(true);
    400   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    401   input_type_ = TEXT_INPUT_TYPE_PASSWORD;
    402   ime_->OnTextInputTypeChanged(this);
    403   EXPECT_EQ(TEXT_INPUT_TYPE_PASSWORD, ime_->GetTextInputType());
    404   input_type_ = TEXT_INPUT_TYPE_TEXT;
    405   ime_->OnTextInputTypeChanged(this);
    406   EXPECT_EQ(TEXT_INPUT_TYPE_TEXT, ime_->GetTextInputType());
    407 }
    408 
    409 TEST_F(InputMethodChromeOSTest, CanComposeInline) {
    410   ime_->Init(true);
    411   EXPECT_TRUE(ime_->CanComposeInline());
    412   can_compose_inline_ = false;
    413   ime_->OnTextInputTypeChanged(this);
    414   EXPECT_FALSE(ime_->CanComposeInline());
    415 }
    416 
    417 TEST_F(InputMethodChromeOSTest, GetTextInputClient) {
    418   ime_->Init(true);
    419   EXPECT_EQ(this, ime_->GetTextInputClient());
    420   if (switches::IsTextInputFocusManagerEnabled())
    421     TextInputFocusManager::GetInstance()->BlurTextInputClient(this);
    422   else
    423     ime_->SetFocusedTextInputClient(NULL);
    424   EXPECT_EQ(NULL, ime_->GetTextInputClient());
    425 }
    426 
    427 TEST_F(InputMethodChromeOSTest, GetInputTextType_WithoutFocusedClient) {
    428   ime_->Init(true);
    429   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    430   if (switches::IsTextInputFocusManagerEnabled())
    431     TextInputFocusManager::GetInstance()->BlurTextInputClient(this);
    432   else
    433     ime_->SetFocusedTextInputClient(NULL);
    434   input_type_ = TEXT_INPUT_TYPE_PASSWORD;
    435   ime_->OnTextInputTypeChanged(this);
    436   // The OnTextInputTypeChanged() call above should be ignored since |this| is
    437   // not the current focused client.
    438   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    439 
    440   if (switches::IsTextInputFocusManagerEnabled())
    441     TextInputFocusManager::GetInstance()->FocusTextInputClient(this);
    442   else
    443     ime_->SetFocusedTextInputClient(this);
    444   ime_->OnTextInputTypeChanged(this);
    445   EXPECT_EQ(TEXT_INPUT_TYPE_PASSWORD, ime_->GetTextInputType());
    446 }
    447 
    448 TEST_F(InputMethodChromeOSTest, GetInputTextType_WithoutFocusedWindow) {
    449   ime_->Init(true);
    450   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    451   if (switches::IsTextInputFocusManagerEnabled())
    452     TextInputFocusManager::GetInstance()->BlurTextInputClient(this);
    453   else
    454     ime_->OnBlur();
    455   input_type_ = TEXT_INPUT_TYPE_PASSWORD;
    456   ime_->OnTextInputTypeChanged(this);
    457   // The OnTextInputTypeChanged() call above should be ignored since the top-
    458   // level window which the ime_ is attached to is not currently focused.
    459   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    460 
    461   if (switches::IsTextInputFocusManagerEnabled())
    462     TextInputFocusManager::GetInstance()->FocusTextInputClient(this);
    463   else
    464     ime_->OnFocus();
    465   ime_->OnTextInputTypeChanged(this);
    466   EXPECT_EQ(TEXT_INPUT_TYPE_PASSWORD, ime_->GetTextInputType());
    467 }
    468 
    469 TEST_F(InputMethodChromeOSTest, GetInputTextType_WithoutFocusedWindow2) {
    470   // We no longer support the case that |ime_->Init(false)| because no one
    471   // actually uses it.
    472   if (switches::IsTextInputFocusManagerEnabled())
    473     return;
    474 
    475   ime_->Init(false);  // the top-level is initially unfocused.
    476   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    477   input_type_ = TEXT_INPUT_TYPE_PASSWORD;
    478   ime_->OnTextInputTypeChanged(this);
    479   EXPECT_EQ(TEXT_INPUT_TYPE_NONE, ime_->GetTextInputType());
    480 
    481   ime_->OnFocus();
    482   ime_->OnTextInputTypeChanged(this);
    483   EXPECT_EQ(TEXT_INPUT_TYPE_PASSWORD, ime_->GetTextInputType());
    484 }
    485 
    486 // Confirm that IBusClient::FocusIn is called on "connected" if input_type_ is
    487 // TEXT.
    488 TEST_F(InputMethodChromeOSTest, FocusIn_Text) {
    489   ime_->Init(true);
    490   // A context shouldn't be created since the daemon is not running.
    491   EXPECT_EQ(0U, on_input_method_changed_call_count_);
    492   // Click a text input form.
    493   input_type_ = TEXT_INPUT_TYPE_TEXT;
    494   ime_->OnTextInputTypeChanged(this);
    495   // Since a form has focus, IBusClient::FocusIn() should be called.
    496   EXPECT_EQ(1, mock_ime_engine_handler_->focus_in_call_count());
    497   EXPECT_EQ(
    498       1,
    499       mock_ime_candidate_window_handler_->set_cursor_bounds_call_count());
    500   // ui::TextInputClient::OnInputMethodChanged() should be called when
    501   // ui::InputMethodChromeOS connects/disconnects to/from ibus-daemon and the
    502   // current text input type is not NONE.
    503   EXPECT_EQ(1U, on_input_method_changed_call_count_);
    504 }
    505 
    506 // Confirm that InputMethodEngine::FocusIn is called on "connected" even if
    507 // input_type_ is PASSWORD.
    508 TEST_F(InputMethodChromeOSTest, FocusIn_Password) {
    509   ime_->Init(true);
    510   EXPECT_EQ(0U, on_input_method_changed_call_count_);
    511   input_type_ = TEXT_INPUT_TYPE_PASSWORD;
    512   ime_->OnTextInputTypeChanged(this);
    513   // InputMethodEngine::FocusIn() should be called even for password field.
    514   EXPECT_EQ(1, mock_ime_engine_handler_->focus_in_call_count());
    515   EXPECT_EQ(1U, on_input_method_changed_call_count_);
    516 }
    517 
    518 // Confirm that IBusClient::FocusOut is called as expected.
    519 TEST_F(InputMethodChromeOSTest, FocusOut_None) {
    520   input_type_ = TEXT_INPUT_TYPE_TEXT;
    521   ime_->Init(true);
    522   EXPECT_EQ(1, mock_ime_engine_handler_->focus_in_call_count());
    523   EXPECT_EQ(0, mock_ime_engine_handler_->focus_out_call_count());
    524   input_type_ = TEXT_INPUT_TYPE_NONE;
    525   ime_->OnTextInputTypeChanged(this);
    526   EXPECT_EQ(1, mock_ime_engine_handler_->focus_in_call_count());
    527   EXPECT_EQ(1, mock_ime_engine_handler_->focus_out_call_count());
    528 }
    529 
    530 // Confirm that IBusClient::FocusOut is called as expected.
    531 TEST_F(InputMethodChromeOSTest, FocusOut_Password) {
    532   input_type_ = TEXT_INPUT_TYPE_TEXT;
    533   ime_->Init(true);
    534   EXPECT_EQ(1, mock_ime_engine_handler_->focus_in_call_count());
    535   EXPECT_EQ(0, mock_ime_engine_handler_->focus_out_call_count());
    536   input_type_ = TEXT_INPUT_TYPE_PASSWORD;
    537   ime_->OnTextInputTypeChanged(this);
    538   EXPECT_EQ(2, mock_ime_engine_handler_->focus_in_call_count());
    539   EXPECT_EQ(1, mock_ime_engine_handler_->focus_out_call_count());
    540 }
    541 
    542 // FocusIn/FocusOut scenario test
    543 TEST_F(InputMethodChromeOSTest, Focus_Scenario) {
    544   ime_->Init(true);
    545   // Confirm that both FocusIn and FocusOut are NOT called.
    546   EXPECT_EQ(0, mock_ime_engine_handler_->focus_in_call_count());
    547   EXPECT_EQ(0, mock_ime_engine_handler_->focus_out_call_count());
    548   EXPECT_EQ(TEXT_INPUT_TYPE_NONE,
    549             mock_ime_engine_handler_->last_text_input_context().type);
    550   EXPECT_EQ(TEXT_INPUT_MODE_DEFAULT,
    551             mock_ime_engine_handler_->last_text_input_context().mode);
    552 
    553   input_type_ = TEXT_INPUT_TYPE_TEXT;
    554   input_mode_ = TEXT_INPUT_MODE_LATIN;
    555   ime_->OnTextInputTypeChanged(this);
    556   // Confirm that only FocusIn is called, the TextInputType is TEXT and the
    557   // TextInputMode is LATIN..
    558   EXPECT_EQ(1, mock_ime_engine_handler_->focus_in_call_count());
    559   EXPECT_EQ(0, mock_ime_engine_handler_->focus_out_call_count());
    560   EXPECT_EQ(TEXT_INPUT_TYPE_TEXT,
    561             mock_ime_engine_handler_->last_text_input_context().type);
    562   EXPECT_EQ(TEXT_INPUT_MODE_LATIN,
    563             mock_ime_engine_handler_->last_text_input_context().mode);
    564 
    565   input_mode_ = TEXT_INPUT_MODE_KANA;
    566   ime_->OnTextInputTypeChanged(this);
    567   // Confirm that both FocusIn and FocusOut are called for mode change.
    568   EXPECT_EQ(2, mock_ime_engine_handler_->focus_in_call_count());
    569   EXPECT_EQ(1, mock_ime_engine_handler_->focus_out_call_count());
    570   EXPECT_EQ(TEXT_INPUT_TYPE_TEXT,
    571             mock_ime_engine_handler_->last_text_input_context().type);
    572   EXPECT_EQ(TEXT_INPUT_MODE_KANA,
    573             mock_ime_engine_handler_->last_text_input_context().mode);
    574 
    575   input_type_ = TEXT_INPUT_TYPE_URL;
    576   ime_->OnTextInputTypeChanged(this);
    577   // Confirm that both FocusIn and FocusOut are called and the TextInputType is
    578   // changed to URL.
    579   EXPECT_EQ(3, mock_ime_engine_handler_->focus_in_call_count());
    580   EXPECT_EQ(2, mock_ime_engine_handler_->focus_out_call_count());
    581   EXPECT_EQ(TEXT_INPUT_TYPE_URL,
    582             mock_ime_engine_handler_->last_text_input_context().type);
    583   EXPECT_EQ(TEXT_INPUT_MODE_KANA,
    584             mock_ime_engine_handler_->last_text_input_context().mode);
    585 
    586   // When IsTextInputFocusManagerEnabled, InputMethod::SetFocusedTextInputClient
    587   // is not supported and it's no-op.
    588   if (switches::IsTextInputFocusManagerEnabled())
    589     return;
    590   // Confirm that FocusOut is called when set focus to NULL client.
    591   ime_->SetFocusedTextInputClient(NULL);
    592   EXPECT_EQ(3, mock_ime_engine_handler_->focus_in_call_count());
    593   EXPECT_EQ(3, mock_ime_engine_handler_->focus_out_call_count());
    594   // Confirm that FocusIn is called when set focus to this client.
    595   ime_->SetFocusedTextInputClient(this);
    596   EXPECT_EQ(4, mock_ime_engine_handler_->focus_in_call_count());
    597   EXPECT_EQ(3, mock_ime_engine_handler_->focus_out_call_count());
    598 }
    599 
    600 // Test if the new |caret_bounds_| is correctly sent to ibus-daemon.
    601 TEST_F(InputMethodChromeOSTest, OnCaretBoundsChanged) {
    602   input_type_ = TEXT_INPUT_TYPE_TEXT;
    603   ime_->Init(true);
    604   EXPECT_EQ(
    605       1,
    606       mock_ime_candidate_window_handler_->set_cursor_bounds_call_count());
    607   caret_bounds_ = gfx::Rect(1, 2, 3, 4);
    608   ime_->OnCaretBoundsChanged(this);
    609   EXPECT_EQ(
    610       2,
    611       mock_ime_candidate_window_handler_->set_cursor_bounds_call_count());
    612   caret_bounds_ = gfx::Rect(0, 2, 3, 4);
    613   ime_->OnCaretBoundsChanged(this);
    614   EXPECT_EQ(
    615       3,
    616       mock_ime_candidate_window_handler_->set_cursor_bounds_call_count());
    617   caret_bounds_ = gfx::Rect(0, 2, 3, 4);  // unchanged
    618   ime_->OnCaretBoundsChanged(this);
    619   // Current InputMethodChromeOS implementation performs the IPC
    620   // regardless of the bounds are changed or not.
    621   EXPECT_EQ(
    622       4,
    623       mock_ime_candidate_window_handler_->set_cursor_bounds_call_count());
    624 }
    625 
    626 TEST_F(InputMethodChromeOSTest, ExtractCompositionTextTest_NoAttribute) {
    627   const base::string16 kSampleAsciiText = UTF8ToUTF16("Sample Text");
    628   const uint32 kCursorPos = 2UL;
    629 
    630   chromeos::CompositionText chromeos_composition_text;
    631   chromeos_composition_text.set_text(kSampleAsciiText);
    632 
    633   CompositionText composition_text;
    634   ime_->ExtractCompositionText(
    635       chromeos_composition_text, kCursorPos, &composition_text);
    636   EXPECT_EQ(kSampleAsciiText, composition_text.text);
    637   // If there is no selection, |selection| represents cursor position.
    638   EXPECT_EQ(kCursorPos, composition_text.selection.start());
    639   EXPECT_EQ(kCursorPos, composition_text.selection.end());
    640   // If there is no underline, |underlines| contains one underline and it is
    641   // whole text underline.
    642   ASSERT_EQ(1UL, composition_text.underlines.size());
    643   EXPECT_EQ(0UL, composition_text.underlines[0].start_offset);
    644   EXPECT_EQ(kSampleAsciiText.size(), composition_text.underlines[0].end_offset);
    645   EXPECT_FALSE(composition_text.underlines[0].thick);
    646 }
    647 
    648 TEST_F(InputMethodChromeOSTest, ExtractCompositionTextTest_SingleUnderline) {
    649   const uint32 kCursorPos = 2UL;
    650 
    651   // Set up chromeos composition text with one underline attribute.
    652   chromeos::CompositionText chromeos_composition_text;
    653   chromeos_composition_text.set_text(kSampleText);
    654   chromeos::CompositionText::UnderlineAttribute underline;
    655   underline.type = chromeos::CompositionText::COMPOSITION_TEXT_UNDERLINE_SINGLE;
    656   underline.start_index = 1UL;
    657   underline.end_index = 4UL;
    658   chromeos_composition_text.mutable_underline_attributes()->push_back(
    659       underline);
    660 
    661   CompositionText composition_text;
    662   ime_->ExtractCompositionText(
    663       chromeos_composition_text, kCursorPos, &composition_text);
    664   EXPECT_EQ(kSampleText, composition_text.text);
    665   // If there is no selection, |selection| represents cursor position.
    666   EXPECT_EQ(kCursorPos, composition_text.selection.start());
    667   EXPECT_EQ(kCursorPos, composition_text.selection.end());
    668   ASSERT_EQ(1UL, composition_text.underlines.size());
    669   EXPECT_EQ(GetOffsetInUTF16(kSampleText, underline.start_index),
    670             composition_text.underlines[0].start_offset);
    671   EXPECT_EQ(GetOffsetInUTF16(kSampleText, underline.end_index),
    672             composition_text.underlines[0].end_offset);
    673   // Single underline represents as black thin line.
    674   EXPECT_EQ(SK_ColorBLACK, composition_text.underlines[0].color);
    675   EXPECT_FALSE(composition_text.underlines[0].thick);
    676   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
    677             composition_text.underlines[0].background_color);
    678 }
    679 
    680 TEST_F(InputMethodChromeOSTest, ExtractCompositionTextTest_DoubleUnderline) {
    681   const uint32 kCursorPos = 2UL;
    682 
    683   // Set up chromeos composition text with one underline attribute.
    684   chromeos::CompositionText chromeos_composition_text;
    685   chromeos_composition_text.set_text(kSampleText);
    686   chromeos::CompositionText::UnderlineAttribute underline;
    687   underline.type = chromeos::CompositionText::COMPOSITION_TEXT_UNDERLINE_DOUBLE;
    688   underline.start_index = 1UL;
    689   underline.end_index = 4UL;
    690   chromeos_composition_text.mutable_underline_attributes()->push_back(
    691       underline);
    692 
    693   CompositionText composition_text;
    694   ime_->ExtractCompositionText(
    695       chromeos_composition_text, kCursorPos, &composition_text);
    696   EXPECT_EQ(kSampleText, composition_text.text);
    697   // If there is no selection, |selection| represents cursor position.
    698   EXPECT_EQ(kCursorPos, composition_text.selection.start());
    699   EXPECT_EQ(kCursorPos, composition_text.selection.end());
    700   ASSERT_EQ(1UL, composition_text.underlines.size());
    701   EXPECT_EQ(GetOffsetInUTF16(kSampleText, underline.start_index),
    702             composition_text.underlines[0].start_offset);
    703   EXPECT_EQ(GetOffsetInUTF16(kSampleText, underline.end_index),
    704             composition_text.underlines[0].end_offset);
    705   // Double underline represents as black thick line.
    706   EXPECT_EQ(SK_ColorBLACK, composition_text.underlines[0].color);
    707   EXPECT_TRUE(composition_text.underlines[0].thick);
    708   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
    709             composition_text.underlines[0].background_color);
    710 }
    711 
    712 TEST_F(InputMethodChromeOSTest, ExtractCompositionTextTest_ErrorUnderline) {
    713   const uint32 kCursorPos = 2UL;
    714 
    715   // Set up chromeos composition text with one underline attribute.
    716   chromeos::CompositionText chromeos_composition_text;
    717   chromeos_composition_text.set_text(kSampleText);
    718   chromeos::CompositionText::UnderlineAttribute underline;
    719   underline.type = chromeos::CompositionText::COMPOSITION_TEXT_UNDERLINE_ERROR;
    720   underline.start_index = 1UL;
    721   underline.end_index = 4UL;
    722   chromeos_composition_text.mutable_underline_attributes()->push_back(
    723       underline);
    724 
    725   CompositionText composition_text;
    726   ime_->ExtractCompositionText(
    727       chromeos_composition_text, kCursorPos, &composition_text);
    728   EXPECT_EQ(kSampleText, composition_text.text);
    729   EXPECT_EQ(kCursorPos, composition_text.selection.start());
    730   EXPECT_EQ(kCursorPos, composition_text.selection.end());
    731   ASSERT_EQ(1UL, composition_text.underlines.size());
    732   EXPECT_EQ(GetOffsetInUTF16(kSampleText, underline.start_index),
    733             composition_text.underlines[0].start_offset);
    734   EXPECT_EQ(GetOffsetInUTF16(kSampleText, underline.end_index),
    735             composition_text.underlines[0].end_offset);
    736   // Error underline represents as red thin line.
    737   EXPECT_EQ(SK_ColorRED, composition_text.underlines[0].color);
    738   EXPECT_FALSE(composition_text.underlines[0].thick);
    739 }
    740 
    741 TEST_F(InputMethodChromeOSTest, ExtractCompositionTextTest_Selection) {
    742   const uint32 kCursorPos = 2UL;
    743 
    744   // Set up chromeos composition text with one underline attribute.
    745   chromeos::CompositionText chromeos_composition_text;
    746   chromeos_composition_text.set_text(kSampleText);
    747   chromeos_composition_text.set_selection_start(1UL);
    748   chromeos_composition_text.set_selection_end(4UL);
    749 
    750   CompositionText composition_text;
    751   ime_->ExtractCompositionText(
    752       chromeos_composition_text, kCursorPos, &composition_text);
    753   EXPECT_EQ(kSampleText, composition_text.text);
    754   EXPECT_EQ(kCursorPos, composition_text.selection.start());
    755   EXPECT_EQ(kCursorPos, composition_text.selection.end());
    756   ASSERT_EQ(1UL, composition_text.underlines.size());
    757   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    758                              chromeos_composition_text.selection_start()),
    759             composition_text.underlines[0].start_offset);
    760   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    761                              chromeos_composition_text.selection_end()),
    762             composition_text.underlines[0].end_offset);
    763   EXPECT_EQ(SK_ColorBLACK, composition_text.underlines[0].color);
    764   EXPECT_TRUE(composition_text.underlines[0].thick);
    765   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
    766             composition_text.underlines[0].background_color);
    767 }
    768 
    769 TEST_F(InputMethodChromeOSTest,
    770        ExtractCompositionTextTest_SelectionStartWithCursor) {
    771   const uint32 kCursorPos = 1UL;
    772 
    773   // Set up chromeos composition text with one underline attribute.
    774   chromeos::CompositionText chromeos_composition_text;
    775   chromeos_composition_text.set_text(kSampleText);
    776   chromeos_composition_text.set_selection_start(kCursorPos);
    777   chromeos_composition_text.set_selection_end(4UL);
    778 
    779   CompositionText composition_text;
    780   ime_->ExtractCompositionText(
    781       chromeos_composition_text, kCursorPos, &composition_text);
    782   EXPECT_EQ(kSampleText, composition_text.text);
    783   // If the cursor position is same as selection bounds, selection start
    784   // position become opposit side of selection from cursor.
    785   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    786                              chromeos_composition_text.selection_end()),
    787             composition_text.selection.start());
    788   EXPECT_EQ(GetOffsetInUTF16(kSampleText, kCursorPos),
    789             composition_text.selection.end());
    790   ASSERT_EQ(1UL, composition_text.underlines.size());
    791   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    792                              chromeos_composition_text.selection_start()),
    793             composition_text.underlines[0].start_offset);
    794   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    795                              chromeos_composition_text.selection_end()),
    796             composition_text.underlines[0].end_offset);
    797   EXPECT_EQ(SK_ColorBLACK, composition_text.underlines[0].color);
    798   EXPECT_TRUE(composition_text.underlines[0].thick);
    799   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
    800             composition_text.underlines[0].background_color);
    801 }
    802 
    803 TEST_F(InputMethodChromeOSTest,
    804        ExtractCompositionTextTest_SelectionEndWithCursor) {
    805   const uint32 kCursorPos = 4UL;
    806 
    807   // Set up chromeos composition text with one underline attribute.
    808   chromeos::CompositionText chromeos_composition_text;
    809   chromeos_composition_text.set_text(kSampleText);
    810   chromeos_composition_text.set_selection_start(1UL);
    811   chromeos_composition_text.set_selection_end(kCursorPos);
    812 
    813   CompositionText composition_text;
    814   ime_->ExtractCompositionText(
    815       chromeos_composition_text, kCursorPos, &composition_text);
    816   EXPECT_EQ(kSampleText, composition_text.text);
    817   // If the cursor position is same as selection bounds, selection start
    818   // position become opposit side of selection from cursor.
    819   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    820                              chromeos_composition_text.selection_start()),
    821             composition_text.selection.start());
    822   EXPECT_EQ(GetOffsetInUTF16(kSampleText, kCursorPos),
    823             composition_text.selection.end());
    824   ASSERT_EQ(1UL, composition_text.underlines.size());
    825   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    826                              chromeos_composition_text.selection_start()),
    827             composition_text.underlines[0].start_offset);
    828   EXPECT_EQ(GetOffsetInUTF16(kSampleText,
    829                              chromeos_composition_text.selection_end()),
    830             composition_text.underlines[0].end_offset);
    831   EXPECT_EQ(SK_ColorBLACK, composition_text.underlines[0].color);
    832   EXPECT_TRUE(composition_text.underlines[0].thick);
    833   EXPECT_EQ(static_cast<SkColor>(SK_ColorTRANSPARENT),
    834             composition_text.underlines[0].background_color);
    835 }
    836 
    837 TEST_F(InputMethodChromeOSTest, SurroundingText_NoSelectionTest) {
    838   ime_->Init(true);
    839   // Click a text input form.
    840   input_type_ = TEXT_INPUT_TYPE_TEXT;
    841   ime_->OnTextInputTypeChanged(this);
    842 
    843   // Set the TextInputClient behaviors.
    844   surrounding_text_ = UTF8ToUTF16("abcdef");
    845   text_range_ = gfx::Range(0, 6);
    846   selection_range_ = gfx::Range(3, 3);
    847 
    848   // Set the verifier for SetSurroundingText mock call.
    849   SetSurroundingTextVerifier verifier(UTF16ToUTF8(surrounding_text_), 3, 3);
    850 
    851 
    852   ime_->OnCaretBoundsChanged(this);
    853 
    854   // Check the call count.
    855   EXPECT_EQ(1,
    856             mock_ime_engine_handler_->set_surrounding_text_call_count());
    857   EXPECT_EQ(UTF16ToUTF8(surrounding_text_),
    858             mock_ime_engine_handler_->last_set_surrounding_text());
    859   EXPECT_EQ(3U,
    860             mock_ime_engine_handler_->last_set_surrounding_cursor_pos());
    861   EXPECT_EQ(3U,
    862             mock_ime_engine_handler_->last_set_surrounding_anchor_pos());
    863 }
    864 
    865 TEST_F(InputMethodChromeOSTest, SurroundingText_SelectionTest) {
    866   ime_->Init(true);
    867   // Click a text input form.
    868   input_type_ = TEXT_INPUT_TYPE_TEXT;
    869   ime_->OnTextInputTypeChanged(this);
    870 
    871   // Set the TextInputClient behaviors.
    872   surrounding_text_ = UTF8ToUTF16("abcdef");
    873   text_range_ = gfx::Range(0, 6);
    874   selection_range_ = gfx::Range(2, 5);
    875 
    876   // Set the verifier for SetSurroundingText mock call.
    877   SetSurroundingTextVerifier verifier(UTF16ToUTF8(surrounding_text_), 2, 5);
    878 
    879   ime_->OnCaretBoundsChanged(this);
    880 
    881   // Check the call count.
    882   EXPECT_EQ(1,
    883             mock_ime_engine_handler_->set_surrounding_text_call_count());
    884   EXPECT_EQ(UTF16ToUTF8(surrounding_text_),
    885             mock_ime_engine_handler_->last_set_surrounding_text());
    886   EXPECT_EQ(2U,
    887             mock_ime_engine_handler_->last_set_surrounding_cursor_pos());
    888   EXPECT_EQ(5U,
    889             mock_ime_engine_handler_->last_set_surrounding_anchor_pos());
    890 }
    891 
    892 TEST_F(InputMethodChromeOSTest, SurroundingText_PartialText) {
    893   ime_->Init(true);
    894   // Click a text input form.
    895   input_type_ = TEXT_INPUT_TYPE_TEXT;
    896   ime_->OnTextInputTypeChanged(this);
    897 
    898   // Set the TextInputClient behaviors.
    899   surrounding_text_ = UTF8ToUTF16("abcdefghij");
    900   text_range_ = gfx::Range(5, 10);
    901   selection_range_ = gfx::Range(7, 9);
    902 
    903   ime_->OnCaretBoundsChanged(this);
    904 
    905   // Check the call count.
    906   EXPECT_EQ(1,
    907             mock_ime_engine_handler_->set_surrounding_text_call_count());
    908   // Set the verifier for SetSurroundingText mock call.
    909   // Here (2, 4) is selection range in expected surrounding text coordinates.
    910   EXPECT_EQ("fghij",
    911             mock_ime_engine_handler_->last_set_surrounding_text());
    912   EXPECT_EQ(2U,
    913             mock_ime_engine_handler_->last_set_surrounding_cursor_pos());
    914   EXPECT_EQ(4U,
    915             mock_ime_engine_handler_->last_set_surrounding_anchor_pos());
    916 }
    917 
    918 TEST_F(InputMethodChromeOSTest, SurroundingText_BecomeEmptyText) {
    919   ime_->Init(true);
    920   // Click a text input form.
    921   input_type_ = TEXT_INPUT_TYPE_TEXT;
    922   ime_->OnTextInputTypeChanged(this);
    923 
    924   // Set the TextInputClient behaviors.
    925   // If the surrounding text becomes empty, text_range become (0, 0) and
    926   // selection range become invalid.
    927   surrounding_text_ = UTF8ToUTF16("");
    928   text_range_ = gfx::Range(0, 0);
    929   selection_range_ = gfx::Range::InvalidRange();
    930 
    931   ime_->OnCaretBoundsChanged(this);
    932 
    933   // Check the call count.
    934   EXPECT_EQ(0,
    935             mock_ime_engine_handler_->set_surrounding_text_call_count());
    936 
    937   // Should not be called twice with same condition.
    938   ime_->OnCaretBoundsChanged(this);
    939   EXPECT_EQ(0,
    940             mock_ime_engine_handler_->set_surrounding_text_call_count());
    941 }
    942 
    943 class InputMethodChromeOSKeyEventTest : public InputMethodChromeOSTest {
    944  public:
    945   InputMethodChromeOSKeyEventTest() {}
    946   virtual ~InputMethodChromeOSKeyEventTest() {}
    947 
    948   virtual void SetUp() OVERRIDE {
    949     InputMethodChromeOSTest::SetUp();
    950     ime_->Init(true);
    951   }
    952 
    953   DISALLOW_COPY_AND_ASSIGN(InputMethodChromeOSKeyEventTest);
    954 };
    955 
    956 TEST_F(InputMethodChromeOSKeyEventTest, KeyEventDelayResponseTest) {
    957   const int kFlags = ui::EF_SHIFT_DOWN;
    958   ScopedXI2Event xevent;
    959   xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, kFlags);
    960   const ui::KeyEvent event(xevent);
    961 
    962   // Do key event.
    963   input_type_ = TEXT_INPUT_TYPE_TEXT;
    964   ime_->OnTextInputTypeChanged(this);
    965   ime_->DispatchKeyEvent(event);
    966 
    967   // Check before state.
    968   const ui::KeyEvent* key_event =
    969       mock_ime_engine_handler_->last_processed_key_event();
    970   EXPECT_EQ(1, mock_ime_engine_handler_->process_key_event_call_count());
    971   EXPECT_EQ(ui::VKEY_A, key_event->key_code());
    972   EXPECT_EQ("KeyA", key_event->code());
    973   EXPECT_EQ(kFlags, key_event->flags());
    974   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
    975 
    976   // Do callback.
    977   mock_ime_engine_handler_->last_passed_callback().Run(true);
    978 
    979   // Check the results
    980   EXPECT_EQ(1, ime_->process_key_event_post_ime_call_count());
    981   const ui::KeyEvent* stored_event =
    982       ime_->process_key_event_post_ime_args().event;
    983   EXPECT_TRUE(stored_event->HasNativeEvent());
    984   EXPECT_TRUE(IsEqualXKeyEvent(*xevent, *(stored_event->native_event())));
    985   EXPECT_TRUE(ime_->process_key_event_post_ime_args().handled);
    986 }
    987 
    988 TEST_F(InputMethodChromeOSKeyEventTest, MultiKeyEventDelayResponseTest) {
    989   // Preparation
    990   input_type_ = TEXT_INPUT_TYPE_TEXT;
    991   ime_->OnTextInputTypeChanged(this);
    992 
    993   const int kFlags = ui::EF_SHIFT_DOWN;
    994   ScopedXI2Event xevent;
    995   xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_B, kFlags);
    996   const ui::KeyEvent event(xevent);
    997 
    998   // Do key event.
    999   ime_->DispatchKeyEvent(event);
   1000   const ui::KeyEvent* key_event =
   1001       mock_ime_engine_handler_->last_processed_key_event();
   1002   EXPECT_EQ(ui::VKEY_B, key_event->key_code());
   1003   EXPECT_EQ("KeyB", key_event->code());
   1004   EXPECT_EQ(kFlags, key_event->flags());
   1005 
   1006   KeyEventCallback first_callback =
   1007       mock_ime_engine_handler_->last_passed_callback();
   1008 
   1009   // Do key event again.
   1010   ScopedXI2Event xevent2;
   1011   xevent2.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_C, kFlags);
   1012   const ui::KeyEvent event2(xevent2);
   1013 
   1014   ime_->DispatchKeyEvent(event2);
   1015   const ui::KeyEvent* key_event2 =
   1016       mock_ime_engine_handler_->last_processed_key_event();
   1017   EXPECT_EQ(ui::VKEY_C, key_event2->key_code());
   1018   EXPECT_EQ("KeyC", key_event2->code());
   1019   EXPECT_EQ(kFlags, key_event2->flags());
   1020 
   1021   // Check before state.
   1022   EXPECT_EQ(2,
   1023             mock_ime_engine_handler_->process_key_event_call_count());
   1024   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
   1025 
   1026   // Do callback for first key event.
   1027   first_callback.Run(true);
   1028 
   1029   // Check the results for first key event.
   1030   EXPECT_EQ(1, ime_->process_key_event_post_ime_call_count());
   1031   const ui::KeyEvent* stored_event =
   1032       ime_->process_key_event_post_ime_args().event;
   1033   EXPECT_TRUE(stored_event->HasNativeEvent());
   1034   EXPECT_TRUE(IsEqualXKeyEvent(*xevent, *(stored_event->native_event())));
   1035   EXPECT_TRUE(ime_->process_key_event_post_ime_args().handled);
   1036 
   1037   // Do callback for second key event.
   1038   mock_ime_engine_handler_->last_passed_callback().Run(false);
   1039 
   1040   // Check the results for second key event.
   1041   EXPECT_EQ(2, ime_->process_key_event_post_ime_call_count());
   1042   stored_event = ime_->process_key_event_post_ime_args().event;
   1043   EXPECT_TRUE(stored_event->HasNativeEvent());
   1044   EXPECT_TRUE(IsEqualXKeyEvent(*xevent2, *(stored_event->native_event())));
   1045   EXPECT_FALSE(ime_->process_key_event_post_ime_args().handled);
   1046 }
   1047 
   1048 TEST_F(InputMethodChromeOSKeyEventTest, KeyEventDelayResponseResetTest) {
   1049   ScopedXI2Event xevent;
   1050   xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_SHIFT_DOWN);
   1051   const ui::KeyEvent event(xevent);
   1052 
   1053   // Do key event.
   1054   input_type_ = TEXT_INPUT_TYPE_TEXT;
   1055   ime_->OnTextInputTypeChanged(this);
   1056   ime_->DispatchKeyEvent(event);
   1057 
   1058   // Check before state.
   1059   EXPECT_EQ(1, mock_ime_engine_handler_->process_key_event_call_count());
   1060   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
   1061 
   1062   ime_->ResetContext();
   1063 
   1064   // Do callback.
   1065   mock_ime_engine_handler_->last_passed_callback().Run(true);
   1066 
   1067   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
   1068 }
   1069 // TODO(nona): Introduce ProcessKeyEventPostIME tests(crbug.com/156593).
   1070 
   1071 }  // namespace ui
   1072