make IsRepeated work even when a KeyEvent is created from the same native event.

ui/events/event_unittest.cc

 // Copyright (c) 2012 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 "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/keycodes/dom3/dom_code.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
@@ skipping 388 matching lines @@
   }
 #endif  // OS_WIN
 }
 
 namespace {
 #if defined(USE_X11)
 void SetKeyEventTimestamp(XEvent* event, long time) {
   event->xkey.time = time;
 }
 
+void AdvanceKeyEventTimestamp(XEvent* event) {
+  event->xkey.time++;
+}
+
 #elif defined(OS_WIN)
 void SetKeyEventTimestamp(MSG& msg, long time) {
   msg.time = time;
 }
+
+void AdvanceKeyEventTimestamp(MSG& msg) {
+  msg.time++;
+}
 #endif
 }  // namespace
 
 #if defined(USE_X11) || defined(OS_WIN)
 TEST(EventTest, AutoRepeat) {
   const uint16 kNativeCodeA = ui::KeycodeConverter::CodeToNativeKeycode("KeyA");
   const uint16 kNativeCodeB = ui::KeycodeConverter::CodeToNativeKeycode("KeyB");

[oshima, 2015/03/19 00:46:04]

I though about changing this test to use EventGenerator, but it may be better to
have at least one test that doesn't depend on EventGenerator. Let me know what
you think. 

[sadrul, 2015/03/19 10:36:53]

Sounds good.

 #if defined(USE_X11)
   ScopedXI2Event native_event_a_pressed;
   native_event_a_pressed.InitKeyEvent(ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
   ScopedXI2Event native_event_a_pressed_1500;
   native_event_a_pressed_1500.InitKeyEvent(
       ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
   ScopedXI2Event native_event_a_pressed_3000;
   native_event_a_pressed_3000.InitKeyEvent(
       ET_KEY_PRESSED, VKEY_A, kNativeCodeA);
 
@@ skipping 15 matching lines @@
   MSG native_event_a_pressed_3000 = { NULL, WM_KEYDOWN, VKEY_A, lParam_a };
   MSG native_event_a_released = { NULL, WM_KEYUP, VKEY_A, lParam_a };
   MSG native_event_b_pressed = { NULL, WM_KEYUP, VKEY_B, lParam_b };
 #endif
   SetKeyEventTimestamp(native_event_a_pressed_1500, 1500);
   SetKeyEventTimestamp(native_event_a_pressed_3000, 3000);
 
   {
     KeyEvent key_a1(native_event_a_pressed);
     EXPECT_FALSE(key_a1.IsRepeat());
+
+    KeyEvent key_a1_with_same_event(native_event_a_pressed);
+    EXPECT_FALSE(key_a1_with_same_event.IsRepeat());
+
     KeyEvent key_a1_released(native_event_a_released);
     EXPECT_FALSE(key_a1_released.IsRepeat());
 
     KeyEvent key_a2(native_event_a_pressed);
     EXPECT_FALSE(key_a2.IsRepeat());
+
+    AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a2_repeated(native_event_a_pressed);
     EXPECT_TRUE(key_a2_repeated.IsRepeat());
+
     KeyEvent key_a2_released(native_event_a_released);
     EXPECT_FALSE(key_a2_released.IsRepeat());
   }
 
+  // Interleaved with different key press.
   {
     KeyEvent key_a3(native_event_a_pressed);
     EXPECT_FALSE(key_a3.IsRepeat());
+
     KeyEvent key_b(native_event_b_pressed);
     EXPECT_FALSE(key_b.IsRepeat());
+
+    AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a3_again(native_event_a_pressed);
     EXPECT_FALSE(key_a3_again.IsRepeat());
+
+    AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a3_repeated(native_event_a_pressed);
     EXPECT_TRUE(key_a3_repeated.IsRepeat());
+
+    AdvanceKeyEventTimestamp(native_event_a_pressed);
     KeyEvent key_a3_repeated2(native_event_a_pressed);
     EXPECT_TRUE(key_a3_repeated2.IsRepeat());
+
     KeyEvent key_a3_released(native_event_a_released);
     EXPECT_FALSE(key_a3_released.IsRepeat());
   }
 
   // Hold the key longer than max auto repeat timeout.
   {
     KeyEvent key_a4_0(native_event_a_pressed);
     EXPECT_FALSE(key_a4_0.IsRepeat());
+
     KeyEvent key_a4_1500(native_event_a_pressed_1500);
     EXPECT_TRUE(key_a4_1500.IsRepeat());
+
     KeyEvent key_a4_3000(native_event_a_pressed_3000);
     EXPECT_TRUE(key_a4_3000.IsRepeat());
+
     KeyEvent key_a4_released(native_event_a_released);
     EXPECT_FALSE(key_a4_released.IsRepeat());
   }
 
 #if defined(USE_X11)
   {
     KeyEvent key_a4_pressed(native_event_a_pressed);
     EXPECT_FALSE(key_a4_pressed.IsRepeat());
 
     KeyEvent key_a4_pressed_nonstandard_state(
@@ skipping 62 matching lines @@
 
   {
     const float angle_too_big = 400;
     TouchEvent event(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), 0, 0, time,
                     radius_x, radius_y, angle_too_big, 0);
     EXPECT_FLOAT_EQ(400 - 360, event.rotation_angle());
   }
 }
 
 }  // namespace ui