Distinguish between keystroke and character events.

chrome/browser/chromeos/events/event_rewriter_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 "chrome/browser/chromeos/events/event_rewriter.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/sticky_keys/sticky_keys_controller.h"
@@ skipping 46 matching lines @@
 
 std::string GetKeyEventAsString(const ui::KeyEvent& keyevent) {
   return GetExpectedResultAsString(
       keyevent.key_code(), keyevent.flags(), keyevent.type());
 }
 
 std::string GetRewrittenEventAsString(chromeos::EventRewriter* rewriter,
                                       ui::KeyboardCode ui_keycode,
                                       int ui_flags,
                                       ui::EventType ui_type) {
-  const ui::KeyEvent event(ui_type, ui_keycode, ui_flags, false);
+  const ui::KeyEvent event(ui_type, ui_keycode, ui_flags);
   scoped_ptr<ui::Event> new_event;
   rewriter->RewriteEvent(event, &new_event);
   if (new_event)
     return GetKeyEventAsString(
         static_cast<const ui::KeyEvent&>(*new_event.get()));
   return GetKeyEventAsString(event);
 }
 
 // Table entry for simple single key event rewriting tests.
 struct KeyTestCase {
@@ skipping 14 matching lines @@
     int flags;
   } input, expected;
 };
 
 #if defined(USE_X11)
 // Check rewriting of an X11-based key event.
 void CheckX11KeyTestCase(const std::string& expected,
                          chromeos::EventRewriter* rewriter,
                          const KeyTestCase& test,
                          XEvent* xevent) {
-  ui::KeyEvent xkey_event(xevent, false);
+  ui::KeyEvent xkey_event(xevent);
   if (test.test & KeyTestCase::NUMPAD)
     xkey_event.set_flags(xkey_event.flags() | ui::EF_NUMPAD_KEY);
   // Verify that the X11-based key event is as expected.
   EXPECT_EQ(GetExpectedResultAsString(
                      test.input.key_code, test.input.flags, test.type),
             GetKeyEventAsString(xkey_event));
   // Rewrite the event and check the result.
   scoped_ptr<ui::Event> new_event;
   rewriter->RewriteEvent(xkey_event, &new_event);
   ui::KeyEvent& rewritten_key_event =
       new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event;
   EXPECT_EQ(expected, GetKeyEventAsString(rewritten_key_event));
   if ((rewritten_key_event.key_code() != ui::VKEY_UNKNOWN) &&
       (rewritten_key_event.native_event()->xkey.keycode != 0)) {
     // Build a new ui::KeyEvent from the rewritten native component,
     // and check that it also matches the rewritten event.
     EXPECT_TRUE(rewritten_key_event.native_event());
-    ui::KeyEvent from_native_event(rewritten_key_event.native_event(), false);
+    ui::KeyEvent from_native_event(rewritten_key_event.native_event());
     EXPECT_EQ(expected, GetKeyEventAsString(from_native_event));
   }
 }
 #endif
 
 // Tests a single stateless key rewrite operation.
 // |i| is a an identifying number to locate failing tests in the tables.
 void CheckKeyTestCase(chromeos::EventRewriter* rewriter,
                       const KeyTestCase& test) {
   std::string expected =
@@ skipping 56 matching lines @@
   EXPECT_EQ(
       vkey_expected,
       GetRewrittenEventAsString(
                rewriter, test.input.key_code, test.input.flags, test.type));
 
 #if defined(USE_X11)
   ui::ScopedXI2Event xev;
   xev.InitKeyEvent(test.type, test.input.key_code, test.input.flags);
   XEvent* xevent = xev;
   if (xevent->xkey.keycode) {
-    ui::KeyEvent xkey_event(xevent, false);
+    ui::KeyEvent xkey_event(xevent);
     // Rewrite the event and check the result.
     scoped_ptr<ui::Event> new_event;
     rewriter->RewriteEvent(xkey_event, &new_event);
     ui::KeyEvent& rewritten_key_event =
         new_event ? *static_cast<ui::KeyEvent*>(new_event.get()) : xkey_event;
     std::string native_expected =
         GetExpectedResultAsString(
             test.native_expected.key_code,
             test.native_expected.flags,
             test.type);
@@ skipping 1498 matching lines @@
   control.Init(prefs::kLanguageRemapControlKeyTo, &prefs);
   control.SetValue(chromeos::input_method::kAltKey);
 
   EventRewriter rewriter(NULL);
   rewriter.KeyboardDeviceAddedForTesting(kKeyboardDeviceId, "PC Keyboard");
   rewriter.set_pref_service_for_testing(&prefs);
 
   // Send left control press.
   {
     ui::KeyEvent keyevent(
-        ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, ui::EF_FINAL, false);
+        ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, ui::EF_FINAL);
     scoped_ptr<ui::Event> new_event;
     // Control should NOT be remapped to Alt if EF_FINAL is set.
     EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
               rewriter.RewriteEvent(keyevent, &new_event));
     EXPECT_FALSE(new_event);
   }
 #if defined(USE_X11)
   // Send left control press, using XI2 native events.
   {
     ui::ScopedXI2Event xev;
     xev.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_CONTROL, 0);
     XEvent* xevent = xev;
     xevent->xkey.keycode = XKeysymToKeycode(gfx::GetXDisplay(), XK_Control_L);
     xevent->xkey.send_event = True;  // XSendEvent() always does this.
-    ui::KeyEvent keyevent(xev, false /* is_char */);
+    ui::KeyEvent keyevent(xev);
     scoped_ptr<ui::Event> new_event;
     // Control should NOT be remapped to Alt if send_event
     // flag in the event is True.
     EXPECT_EQ(ui::EVENT_REWRITE_CONTINUE,
               rewriter.RewriteEvent(keyevent, &new_event));
     EXPECT_FALSE(new_event);
   }
 #endif
 }
 
@@ skipping 83 matching lines @@
   bool RewriteFunctionKeys(const ui::Event& event,
                            scoped_ptr<ui::Event>* rewritten_event) {
     return rewriter_->RewriteEvent(event, rewritten_event);
   }
 
   ui::EventDispatchDetails Send(ui::Event* event) {
     return source_.Send(event);
   }
 
   void SendKeyEvent(ui::EventType type, ui::KeyboardCode key_code) {
-    ui::KeyEvent press(type, key_code, ui::EF_NONE, false);
+    ui::KeyEvent press(type, key_code, ui::EF_NONE);
     ui::EventDispatchDetails details = Send(&press);
     CHECK(!details.dispatcher_destroyed);
   }
 
   void SendActivateStickyKeyPattern(ui::KeyboardCode key_code) {
     SendKeyEvent(ui::ET_KEY_PRESSED, key_code);
     SendKeyEvent(ui::ET_KEY_RELEASED, key_code);
   }
 
  protected:
@@ skipping 38 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(EventRewriterAshTest);
 };
 
 TEST_F(EventRewriterAshTest, TopRowKeysAreFunctionKeys) {
   scoped_ptr<aura::Window> window(CreateTestWindowInShellWithId(1));
   ash::wm::WindowState* window_state = ash::wm::GetWindowState(window.get());
   window_state->Activate();
   ScopedVector<ui::Event> events;
 
   // Create a simulated keypress of F1 targetted at the window.
-  ui::KeyEvent press_f1(ui::ET_KEY_PRESSED, ui::VKEY_F1, 0, false);
+  ui::KeyEvent press_f1(ui::ET_KEY_PRESSED, ui::VKEY_F1, ui::EF_NONE);
 
   // Simulate an apps v2 window that has requested top row keys as function
   // keys. The event should not be rewritten.
   window_state->set_top_row_keys_are_function_keys(true);
   ui::EventDispatchDetails details = Send(&press_f1);
   ASSERT_FALSE(details.dispatcher_destroyed);
   PopEvents(&events);
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(
       GetExpectedResultAsString(ui::VKEY_F1, ui::EF_NONE, ui::ET_KEY_PRESSED),
@@ skipping 285 matching lines @@
 
   SendActivateStickyKeyPattern(ui::VKEY_CONTROL);
   PopEvents(&events);
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
   EXPECT_EQ(ui::VKEY_CONTROL,
             static_cast<ui::KeyEvent*>(events[0])->key_code());
 
   // Test key press event is correctly modified and modifier release
   // event is sent.
-  ui::KeyEvent press(ui::ET_KEY_PRESSED, ui::VKEY_C, ui::EF_NONE, false);
+  ui::KeyEvent press(ui::ET_KEY_PRESSED, ui::VKEY_C, ui::EF_NONE);
   ui::EventDispatchDetails details = Send(&press);
   PopEvents(&events);
   EXPECT_EQ(2u, events.size());
   EXPECT_EQ(ui::ET_KEY_PRESSED, events[0]->type());
   EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code());
   EXPECT_TRUE(events[0]->flags() & ui::EF_CONTROL_DOWN);
   EXPECT_EQ(ui::ET_KEY_RELEASED, events[1]->type());
   EXPECT_EQ(ui::VKEY_CONTROL,
             static_cast<ui::KeyEvent*>(events[1])->key_code());
 
   // Test key release event is not modified.
-  ui::KeyEvent release(ui::ET_KEY_RELEASED, ui::VKEY_C, ui::EF_NONE, false);
+  ui::KeyEvent release(ui::ET_KEY_RELEASED, ui::VKEY_C, ui::EF_NONE);
   details = Send(&release);
   ASSERT_FALSE(details.dispatcher_destroyed);
   PopEvents(&events);
   EXPECT_EQ(1u, events.size());
   EXPECT_EQ(ui::ET_KEY_RELEASED, events[0]->type());
   EXPECT_EQ(ui::VKEY_C, static_cast<ui::KeyEvent*>(events[0])->key_code());
   EXPECT_FALSE(events[0]->flags() & ui::EF_CONTROL_DOWN);
 }
 
 TEST_F(EventRewriterAshTest, MouseEventDispatchImpl) {
@@ skipping 247 matching lines @@
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_TRUE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 
   // Turn off AltGr and Mod3.
   sticky_keys_controller_->SetModifiersEnabled(false, false);
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_ALTGR_DOWN));
   EXPECT_FALSE(overlay_->GetModifierVisible(ui::EF_MOD3_DOWN));
 }
 
 }  // namespace chromeos