Distinguish between keystroke and character events.

ui/base/ime/input_method_chromeos_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/ime/input_method_chromeos.h"
 
 #include <X11/Xlib.h>
 #undef Bool
 #undef FocusIn
 #undef FocusOut
@@ skipping 185 matching lines @@
   const uint32 expected_anchor_position_;
 
   DISALLOW_COPY_AND_ASSIGN(SetSurroundingTextVerifier);
 };
 
 class InputMethodChromeOSTest : public internal::InputMethodDelegate,
                                 public testing::Test,
                                 public TextInputClient {
  public:
   InputMethodChromeOSTest()
-      : dispatched_key_event_(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, 0, false) {
+      : dispatched_key_event_(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, ui::EF_NONE) {
     ResetFlags();
   }
 
   virtual ~InputMethodChromeOSTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     chromeos::IMEBridge::Initialize();
 
     mock_ime_engine_handler_.reset(
@@ skipping 111 matching lines @@
   virtual bool IsEditingCommandEnabled(int command_id) OVERRIDE {
     return false;
   }
   virtual void ExecuteEditingCommand(int command_id) OVERRIDE {}
 
   bool HasNativeEvent() const {
     return dispatched_key_event_.HasNativeEvent();
   }
 
   void ResetFlags() {
-    dispatched_key_event_ = ui::KeyEvent(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN, 0,
-                                         false);
+    dispatched_key_event_ = ui::KeyEvent(ui::ET_UNKNOWN, ui::VKEY_UNKNOWN,
+                                         ui::EF_NONE);
 
     composition_text_.Clear();
     confirmed_text_.Clear();
     inserted_text_.clear();
     inserted_char_ = 0;
     inserted_char_flags_ = 0;
     on_input_method_changed_call_count_ = 0;
 
     input_type_ = TEXT_INPUT_TYPE_NONE;
     input_mode_ = TEXT_INPUT_MODE_DEFAULT;
@@ skipping 600 matching lines @@
     ime_->Init(true);
   }
 
   DISALLOW_COPY_AND_ASSIGN(InputMethodChromeOSKeyEventTest);
 };
 
 TEST_F(InputMethodChromeOSKeyEventTest, KeyEventDelayResponseTest) {
   const int kFlags = ui::EF_SHIFT_DOWN;
   ScopedXI2Event xevent;
   xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, kFlags);
-  const ui::KeyEvent event(xevent, true);
+  const ui::KeyEvent event(xevent);
 
   // Do key event.
   input_type_ = TEXT_INPUT_TYPE_TEXT;
   ime_->OnTextInputTypeChanged(this);
   ime_->DispatchKeyEvent(event);
 
   // Check before state.
   const ui::KeyEvent* key_event =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(1, mock_ime_engine_handler_->process_key_event_call_count());
@@ skipping 15 matching lines @@
 }
 
 TEST_F(InputMethodChromeOSKeyEventTest, MultiKeyEventDelayResponseTest) {
   // Preparation
   input_type_ = TEXT_INPUT_TYPE_TEXT;
   ime_->OnTextInputTypeChanged(this);
 
   const int kFlags = ui::EF_SHIFT_DOWN;
   ScopedXI2Event xevent;
   xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_B, kFlags);
-  const ui::KeyEvent event(xevent, true);
+  const ui::KeyEvent event(xevent);
 
   // Do key event.
   ime_->DispatchKeyEvent(event);
   const ui::KeyEvent* key_event =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(ui::VKEY_B, key_event->key_code());
   EXPECT_EQ("KeyB", key_event->code());
   EXPECT_EQ(kFlags, key_event->flags());
 
   KeyEventCallback first_callback =
       mock_ime_engine_handler_->last_passed_callback();
 
   // Do key event again.
   ScopedXI2Event xevent2;
   xevent2.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_C, kFlags);
-  const ui::KeyEvent event2(xevent2, true);
+  const ui::KeyEvent event2(xevent2);
 
   ime_->DispatchKeyEvent(event2);
   const ui::KeyEvent* key_event2 =
       mock_ime_engine_handler_->last_processed_key_event();
   EXPECT_EQ(ui::VKEY_C, key_event2->key_code());
   EXPECT_EQ("KeyC", key_event2->code());
   EXPECT_EQ(kFlags, key_event2->flags());
 
   // Check before state.
   EXPECT_EQ(2,
@@ skipping 18 matching lines @@
   EXPECT_EQ(2, ime_->process_key_event_post_ime_call_count());
   stored_event = ime_->process_key_event_post_ime_args().event;
   EXPECT_TRUE(stored_event->HasNativeEvent());
   EXPECT_TRUE(IsEqualXKeyEvent(*xevent2, *(stored_event->native_event())));
   EXPECT_FALSE(ime_->process_key_event_post_ime_args().handled);
 }
 
 TEST_F(InputMethodChromeOSKeyEventTest, KeyEventDelayResponseResetTest) {
   ScopedXI2Event xevent;
   xevent.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_SHIFT_DOWN);
-  const ui::KeyEvent event(xevent, true);
+  const ui::KeyEvent event(xevent);
 
   // Do key event.
   input_type_ = TEXT_INPUT_TYPE_TEXT;
   ime_->OnTextInputTypeChanged(this);
   ime_->DispatchKeyEvent(event);
 
   // Check before state.
   EXPECT_EQ(1, mock_ime_engine_handler_->process_key_event_call_count());
   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
 
   ime_->ResetContext();
 
   // Do callback.
   mock_ime_engine_handler_->last_passed_callback().Run(true);
 
   EXPECT_EQ(0, ime_->process_key_event_post_ime_call_count());
 }
 // TODO(nona): Introduce ProcessKeyEventPostIME tests(crbug.com/156593).
 
 }  // namespace ui