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;

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

Oh, does the style guide allow this?

[oshima, 2015/03/19 16:41:57]

Yep, see "Non-Static Class Member Initializers" in
https://chromium-cpp.appspot.com/

+
+  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 15 matching lines @@
 }  // namespace
 
 EventGeneratorDelegate* EventGenerator::default_delegate = NULL;
 
 EventGenerator::EventGenerator(gfx::NativeWindow root_window)
     : current_target_(NULL),
       flags_(0),
       grab_(false),
       async_(false),
       targeting_application_(false),
-      tick_clock_(new base::DefaultTickClock()) {
+      tick_clock_(new TestTickClock()) {
   Init(root_window, NULL);
 }
 
 EventGenerator::EventGenerator(gfx::NativeWindow root_window,
                                const gfx::Point& point)
     : current_location_(point),
       current_target_(NULL),
       flags_(0),
       grab_(false),
       async_(false),
       targeting_application_(false),
-      tick_clock_(new base::DefaultTickClock()) {
+      tick_clock_(new TestTickClock()) {
   Init(root_window, NULL);
 }
 
 EventGenerator::EventGenerator(gfx::NativeWindow root_window,
                                gfx::NativeWindow window)
     : current_target_(NULL),
       flags_(0),
       grab_(false),
       async_(false),
       targeting_application_(false),
-      tick_clock_(new base::DefaultTickClock()) {
+      tick_clock_(new TestTickClock()) {
   Init(root_window, window);
 }
 
 EventGenerator::EventGenerator(EventGeneratorDelegate* delegate)
     : delegate_(delegate),
       current_target_(NULL),
       flags_(0),
       grab_(false),
       async_(false),
       targeting_application_(false),
-      tick_clock_(new base::DefaultTickClock()) {
+      tick_clock_(new TestTickClock()) {
   Init(NULL, NULL);
 }
 
 EventGenerator::~EventGenerator() {
   for (std::list<ui::Event*>::iterator i = pending_events_.begin();
       i != pending_events_.end(); ++i)
     delete *i;
   pending_events_.clear();
   delegate()->SetContext(NULL, NULL, NULL);
 }
@@ skipping 415 matching lines @@
     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