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

ui/events/test/event_generator.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/events/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
+#include "base/time/tick_clock.h"
 #include "ui/events/event.h"
 #include "ui/events/event_source.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/test/events_test_utils.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
 #if defined(OS_WIN)
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #endif
 
 namespace ui {
 namespace test {
 namespace {
 
 void DummyCallback(EventType, const gfx::Vector2dF&) {
 }
 
+class TestTickClock : public base::TickClock {
+ public:
+  // Starts off with a clock set to TimeTicks().
+  TestTickClock() {}
+
+  base::TimeTicks NowTicks() override {
+    return base::TimeTicks::FromInternalValue(ticks_++ * 1000);
+  }
+
+ private:
+  int64 ticks_ = 1;
+
+  DISALLOW_COPY_AND_ASSIGN(TestTickClock);
+};
+
 class TestKeyEvent : public ui::KeyEvent {
  public:
   TestKeyEvent(const base::NativeEvent& native_event, int flags)
       : KeyEvent(native_event) {
     set_flags(flags);
   }
 };
 
 class TestTouchEvent : public ui::TouchEvent {
  public:
@@ skipping 466 matching lines @@
   return base::TimeDelta::FromInternalValue(
       tick_clock_->NowTicks().ToInternalValue());
 }
 
 void EventGenerator::Init(gfx::NativeWindow root_window,
                           gfx::NativeWindow window_context) {
   delegate()->SetContext(this, root_window, window_context);
   if (window_context)
     current_location_ = delegate()->CenterOfWindow(window_context);
   current_target_ = delegate()->GetTargetAt(current_location_);
+
+  scoped_ptr<base::TickClock> clock(new TestTickClock);
+  SetTickClock(clock.Pass());
 }
 
 void EventGenerator::DispatchKeyEvent(bool is_press,
                                       ui::KeyboardCode key_code,
                                       int flags) {
 #if defined(OS_WIN)
   UINT key_press = WM_KEYDOWN;
   uint16 character = ui::GetCharacterFromKeyCode(key_code, flags);
   if (is_press && character) {
     MSG native_event = { NULL, WM_KEYDOWN, key_code, 0 };
     TestKeyEvent keyev(native_event, flags);
     Dispatch(&keyev);
     // On Windows, WM_KEYDOWN event is followed by WM_CHAR with a character
     // if the key event cooresponds to a real character.
     key_press = WM_CHAR;
     key_code = static_cast<ui::KeyboardCode>(character);
   }
   MSG native_event =
       { NULL, (is_press ? key_press : WM_KEYUP), key_code, 0 };
+  native_event.time = Now().InMicroseconds();
   TestKeyEvent keyev(native_event, flags);
 #elif defined(USE_X11)
   ui::ScopedXI2Event xevent;
   xevent.InitKeyEvent(is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
                       key_code,
                       flags);
+  static_cast<XEvent*>(xevent)->xkey.time = Now().InMicroseconds();
   ui::KeyEvent keyev(xevent);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
   ui::KeyEvent keyev(type, key_code, flags);
 #endif  // OS_WIN
   Dispatch(&keyev);
 }
 
 void EventGenerator::UpdateCurrentDispatcher(const gfx::Point& point) {
   current_target_ = delegate()->GetTargetAt(point);
@@ skipping 85 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui