Assert event timestamp to be monotonic and not from future

components/test_runner/event_sender.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 "components/test_runner/event_sender.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 1311 matching lines @@
   weak_factory_.InvalidateWeakPtrs();
   current_gesture_location_ = WebPoint(0, 0);
   mouse_event_queue_.clear();
 
   time_offset_ms_ = 0;
   click_count_ = 0;
 
   touch_modifiers_ = 0;
   touch_cancelable_ = true;
   touch_points_.clear();
+
+  if (delegate())
+    delegate()->SetMockMonotonicTimeFunction(base::Callback<double()>());
 }
 
 void EventSender::Install(WebLocalFrame* frame) {
+  delegate()->SetMockMonotonicTimeFunction(
+      base::Bind(&EventSender::GetMockTimeSeconds, base::Unretained(this)));
   EventSenderBindings::Install(weak_factory_.GetWeakPtr(), frame);
 }
 
 void EventSender::SetContextMenuData(const WebContextMenuData& data) {
   last_context_menu_data_.reset(new WebContextMenuData(data));
 }
 
 void EventSender::DoDragDrop(const WebDragData& drag_data,
                               WebDragOperationsMask mask) {
   WebMouseEvent unscaled_event;
   InitMouseEvent(WebInputEvent::MouseDown,
                  current_pointer_state_[kRawMousePointerId].pressed_button_,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_,
+                 GetMockTimeSeconds(), click_count_,
                  current_pointer_state_[kRawMousePointerId].modifiers_,
                  &unscaled_event);
 
   std::unique_ptr<WebInputEvent> scaled_event = ScaleEvent(unscaled_event);
   const WebMouseEvent* event =
       scaled_event.get() ? static_cast<WebMouseEvent*>(scaled_event.get())
                          : &unscaled_event;
 
   WebPoint client_point(event->x, event->y);
   WebPoint screen_point(event->globalX, event->globalY);
+
   current_drag_data_ = drag_data;
   current_drag_effects_allowed_ = mask;
   current_drag_effect_ = view()->dragTargetDragEnter(
       drag_data, client_point, screen_point, current_drag_effects_allowed_,
       modifiersWithButtons(
           current_pointer_state_[kRawMousePointerId].modifiers_,
           current_pointer_state_[kRawMousePointerId].current_buttons_));
 
   // Finish processing events.
   ReplaySavedEvents();
@@ skipping 33 matching lines @@
   current_pointer_state_[pointerId].modifiers_ = modifiers;
 
   if (pointerType == WebPointerProperties::PointerType::Mouse) {
     UpdateClickCountForButton(button_type);
     click_count = click_count_;
   }
   InitMouseEventGeneric(WebInputEvent::MouseDown,
                         current_pointer_state_[pointerId].pressed_button_,
                         current_pointer_state_[pointerId].current_buttons_,
                         current_pointer_state_[pointerId].last_pos_,
-                        GetCurrentEventTimeSec(), click_count,
+                        GetMockTimeSeconds(), click_count,
                         current_pointer_state_[pointerId].modifiers_,
                         pointerType, pointerId, pressure, tiltX, tiltY, &event);
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::PointerUp(int button_number,
                             int modifiers,
                             WebPointerProperties::PointerType pointerType,
                             int pointerId,
@@ skipping 22 matching lines @@
     current_pointer_state_[pointerId].pressed_button_ =
         WebMouseEvent::Button::NoButton;
 
     WebMouseEvent event;
     int click_count = pointerType == WebPointerProperties::PointerType::Mouse
                           ? click_count_
                           : 0;
     InitMouseEventGeneric(WebInputEvent::MouseUp, button_type,
                           current_pointer_state_[pointerId].current_buttons_,
                           current_pointer_state_[pointerId].last_pos_,
-                          GetCurrentEventTimeSec(), click_count, modifiers,
+                          GetMockTimeSeconds(), click_count, modifiers,
                           pointerType, pointerId, pressure, tiltX, tiltY,
                           &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseUp(event);
   }
 }
 
 void EventSender::SetMouseButtonState(int button_number, int modifiers) {
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
@@ skipping 179 matching lines @@
       domCodeString.assign("Digit9");
     }
   }
 
   // For one generated keyboard event, we need to generate a keyDown/keyUp
   // pair;
   // On Windows, we might also need to generate a char event to mimic the
   // Windows event flow; on other platforms we create a merged event and test
   // the event flow that that platform provides.
   WebKeyboardEvent event_down;
-  event_down.timeStampSeconds = GetCurrentEventTimeSec();
+  event_down.timeStampSeconds = GetMockTimeSeconds();
   event_down.type = WebInputEvent::RawKeyDown;
   event_down.modifiers = modifiers;
   event_down.windowsKeyCode = code;
   event_down.domKey = static_cast<int>(
       ui::KeycodeConverter::KeyStringToDomKey(domKeyString));
   event_down.domCode = static_cast<int>(
       ui::KeycodeConverter::CodeStringToDomCode(domCodeString));
 
   if (generate_char) {
     event_down.text[0] = text;
@@ skipping 39 matching lines @@
     delegate()->SetEditCommand(edit_command, "");
 
   HandleInputEventOnViewOrPopup(event_down);
 
   if (code == ui::VKEY_ESCAPE && !current_drag_data_.isNull()) {
     WebMouseEvent event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    current_pointer_state_[kRawMousePointerId].pressed_button_,
                    current_pointer_state_[kRawMousePointerId].current_buttons_,
                    current_pointer_state_[kRawMousePointerId].last_pos_,
-                   GetCurrentEventTimeSec(), click_count_, 0, &event);
+                   GetMockTimeSeconds(), click_count_, 0, &event);
     FinishDragAndDrop(event, blink::WebDragOperationNone);
   }
 
   delegate()->ClearEditCommand();
 
   if (generate_char) {
     WebKeyboardEvent event_char = event_up;
     event_char.type = WebInputEvent::Char;
     HandleInputEventOnViewOrPopup(event_char);
   }
@@ skipping 29 matching lines @@
       WebMouseEvent::Button::NoButton) {
     current_pointer_state_[kRawMousePointerId].pressed_button_ =
         WebMouseEvent::Button::Right;
     current_pointer_state_[kRawMousePointerId].current_buttons_ |=
         GetWebMouseEventModifierForButton(
             current_pointer_state_[kRawMousePointerId].pressed_button_);
   }
   InitMouseEvent(WebInputEvent::MouseDown, WebMouseEvent::Button::Right,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, 0, &event);
+                 GetMockTimeSeconds(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 
 #if defined(OS_WIN)
   current_pointer_state_[kRawMousePointerId].current_buttons_ &=
       ~GetWebMouseEventModifierForButton(WebMouseEvent::Button::Right);
   current_pointer_state_[kRawMousePointerId].pressed_button_ =
       WebMouseEvent::Button::NoButton;
 
   InitMouseEvent(WebInputEvent::MouseUp, WebMouseEvent::Button::Right,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, 0, &event);
+                 GetMockTimeSeconds(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 #endif
 
   std::vector<std::string> menu_items =
       MakeMenuItemStringsFor(last_context_menu_data_.get(), delegate());
   last_context_menu_data_.reset();
   return menu_items;
 }
 
 void EventSender::TextZoomIn() {
@@ skipping 112 matching lines @@
                            filename.utf8().data() + "\n");
 }
 
 void EventSender::GestureFlingCancel() {
   WebGestureEvent event;
   event.type = WebInputEvent::GestureFlingCancel;
   // Generally it won't matter what device we use here, and since it might
   // be cumbersome to expect all callers to specify a device, we'll just
   // choose Touchpad here.
   event.sourceDevice = blink::WebGestureDeviceTouchpad;
-  event.timeStampSeconds = GetCurrentEventTimeSec();
+  event.timeStampSeconds = GetMockTimeSeconds();
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 void EventSender::GestureFlingStart(float x,
                                     float y,
                                     float velocity_x,
@@ skipping 23 matching lines @@
     return;
   }
 
   event.x = x;
   event.y = y;
   event.globalX = event.x;
   event.globalY = event.y;
 
   event.data.flingStart.velocityX = velocity_x;
   event.data.flingStart.velocityY = velocity_y;
-  event.timeStampSeconds = GetCurrentEventTimeSec();
+  event.timeStampSeconds = GetMockTimeSeconds();
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(event);
 }
 
 bool EventSender::IsFlinging() const {
   return view()->isFlinging();
 }
@@ skipping 214 matching lines @@
   } else {
     current_pointer_state_[pointerId].last_pos_ = mouse_pos;
     WebMouseEvent event;
     int click_count = pointerType == WebPointerProperties::PointerType::Mouse
                           ? click_count_
                           : 0;
     InitMouseEventGeneric(
         WebInputEvent::MouseMove,
         current_pointer_state_[kRawMousePointerId].pressed_button_,
         current_pointer_state_[kRawMousePointerId].current_buttons_, mouse_pos,
-        GetCurrentEventTimeSec(), click_count, modifiers, pointerType,
+        GetMockTimeSeconds(), click_count, modifiers, pointerType,
         pointerId, pressure, tiltX, tiltY, &event);
     HandleInputEventOnViewOrPopup(event);
     if (pointerType == WebPointerProperties::PointerType::Mouse)
       DoDragAfterMouseMove(event);
   }
 }
 
 void EventSender::MouseLeave() {
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   WebMouseEvent event;
   InitMouseEvent(WebInputEvent::MouseLeave, WebMouseEvent::Button::NoButton, 0,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, 0, &event);
+                 GetMockTimeSeconds(), click_count_, 0, &event);
   HandleInputEventOnViewOrPopup(event);
 }
 
 
 void EventSender::ScheduleAsynchronousClick(int button_number, int modifiers) {
   delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseDown, weak_factory_.GetWeakPtr(),
                  button_number, modifiers)));
   delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::MouseUp, weak_factory_.GetWeakPtr(),
                  button_number, modifiers)));
 }
 
 void EventSender::ScheduleAsynchronousKeyDown(const std::string& code_str,
                                               int modifiers,
                                               KeyLocationCode location) {
   delegate()->PostTask(new WebCallbackTask(
       base::Bind(&EventSender::KeyDown, weak_factory_.GetWeakPtr(), code_str,
                  modifiers, location)));
 }
 
-double EventSender::GetCurrentEventTimeSec() {
+double EventSender::GetMockTimeSeconds() {
   return (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF() +
          time_offset_ms_ / 1000.0;
 }
 
 void EventSender::DoLeapForward(int milliseconds) {
   time_offset_ms_ += milliseconds;
 }
 
 void EventSender::GetOptionalTouchArgs(gin::Arguments* args,
                                        bool& moved_beyond_slop_region,
@@ skipping 29 matching lines @@
             touch_points_.size());
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   WebTouchEvent touch_event;
   touch_event.type = type;
   touch_event.modifiers = touch_modifiers_;
   touch_event.dispatchType = touch_cancelable_
                                  ? WebInputEvent::Blocking
                                  : WebInputEvent::EventNonBlocking;
-  touch_event.timeStampSeconds = GetCurrentEventTimeSec();
+  touch_event.timeStampSeconds = GetMockTimeSeconds();
   touch_event.movedBeyondSlopRegion = moved_beyond_slop_region;
   touch_event.uniqueTouchEventId = unique_touch_event_id;
   touch_event.touchesLength = touch_points_.size();
   for (size_t i = 0; i < touch_points_.size(); ++i)
     touch_event.touches[i] = touch_points_[i];
   HandleInputEventOnViewOrPopup(touch_event);
 
   for (size_t i = 0; i < touch_points_.size(); ++i) {
     WebTouchPoint* touch_point = &touch_points_[i];
     if (touch_point->state == WebTouchPoint::StateReleased
@@ skipping 227 matching lines @@
       }
       break;
     default:
       NOTREACHED();
   }
 
   event.uniqueTouchEventId = GetUniqueTouchEventId(args);
 
   event.globalX = event.x;
   event.globalY = event.y;
-  event.timeStampSeconds = GetCurrentEventTimeSec();
+  event.timeStampSeconds = GetMockTimeSeconds();
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   WebInputEventResult result = HandleInputEventOnViewOrPopup(event);
 
   // Long press might start a drag drop session. Complete it if so.
   if (type == WebInputEvent::GestureLongPress && !current_drag_data_.isNull()) {
     WebMouseEvent mouse_event;
     InitMouseEvent(WebInputEvent::MouseDown,
                    current_pointer_state_[kRawMousePointerId].pressed_button_,
                    current_pointer_state_[kRawMousePointerId].current_buttons_,
-                   WebPoint(x, y), GetCurrentEventTimeSec(), click_count_,
+                   WebPoint(x, y), GetMockTimeSeconds(), click_count_,
                    current_pointer_state_[kRawMousePointerId].modifiers_,
                    &mouse_event);
 
     FinishDragAndDrop(mouse_event, blink::WebDragOperationNone);
   }
   args->Return(result != WebInputEventResult::NotHandled);
 }
 
 void EventSender::UpdateClickCountForButton(
     WebMouseEvent::Button button_type) {
-  if ((GetCurrentEventTimeSec() - last_click_time_sec_ <
+  if ((GetMockTimeSeconds() - last_click_time_sec_ <
        kMultipleClickTimeSec) &&
       (!OutsideMultiClickRadius(
           current_pointer_state_[kRawMousePointerId].last_pos_,
           last_click_pos_)) &&
       (button_type == last_button_type_)) {
     ++click_count_;
   } else {
     click_count_ = 1;
     last_button_type_ = button_type;
   }
@@ skipping 41 matching lines @@
           }
         }
       }
     }
   }
 
   InitMouseEvent(WebInputEvent::MouseWheel,
                  current_pointer_state_[kRawMousePointerId].pressed_button_,
                  current_pointer_state_[kRawMousePointerId].current_buttons_,
                  current_pointer_state_[kRawMousePointerId].last_pos_,
-                 GetCurrentEventTimeSec(), click_count_, modifiers, event);
+                 GetMockTimeSeconds(), click_count_, modifiers, event);
   event->wheelTicksX = static_cast<float>(horizontal);
   event->wheelTicksY = static_cast<float>(vertical);
   event->deltaX = event->wheelTicksX;
   event->deltaY = event->wheelTicksY;
   event->scrollByPage = paged;
   event->hasPreciseScrollingDeltas = has_precise_scrolling_deltas;
   event->phase = phase;
   if (scroll_type == MouseScrollType::PIXEL) {
     event->wheelTicksX /= kScrollbarPixelsPerTick;
     event->wheelTicksY /= kScrollbarPixelsPerTick;
@@ skipping 126 matching lines @@
     SavedEvent e = mouse_event_queue_.front();
     mouse_event_queue_.pop_front();
 
     switch (e.type) {
       case SavedEvent::TYPE_MOUSE_MOVE: {
         WebMouseEvent event;
         InitMouseEvent(
             WebInputEvent::MouseMove,
             current_pointer_state_[kRawMousePointerId].pressed_button_,
             current_pointer_state_[kRawMousePointerId].current_buttons_, e.pos,
-            GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
+            GetMockTimeSeconds(), click_count_, e.modifiers, &event);
         current_pointer_state_[kRawMousePointerId].last_pos_ =
             WebPoint(event.x, event.y);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseMove(event);
         break;
       }
       case SavedEvent::TYPE_LEAP_FORWARD:
         DoLeapForward(e.milliseconds);
         break;
       case SavedEvent::TYPE_MOUSE_UP: {
         current_pointer_state_[kRawMousePointerId].current_buttons_ &=
             ~GetWebMouseEventModifierForButton(e.button_type);
         current_pointer_state_[kRawMousePointerId].pressed_button_ =
             WebMouseEvent::Button::NoButton;
 
         WebMouseEvent event;
         InitMouseEvent(
             WebInputEvent::MouseUp, e.button_type,
             current_pointer_state_[kRawMousePointerId].current_buttons_,
             current_pointer_state_[kRawMousePointerId].last_pos_,
-            GetCurrentEventTimeSec(), click_count_, e.modifiers, &event);
+            GetMockTimeSeconds(), click_count_, e.modifiers, &event);
         HandleInputEventOnViewOrPopup(event);
         DoDragAfterMouseUp(event);
         break;
       }
       default:
         NOTREACHED();
     }
   }
 
   replaying_saved_events_ = false;
@@ skipping 11 matching lines @@
     if (!WebInputEvent::isKeyboardEventType(event->type))
       return popup->handleInputEvent(*event);
   }
   return view()->handleInputEvent(*event);
 }
 
 void EventSender::SendGesturesForMouseWheelEvent(
     const WebMouseWheelEvent wheel_event) {
   WebGestureEvent begin_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollBegin,
-                                 GetCurrentEventTimeSec(), wheel_event,
+                                 GetMockTimeSeconds(), wheel_event,
                                  &begin_event);
   begin_event.data.scrollBegin.deltaXHint = wheel_event.deltaX;
   begin_event.data.scrollBegin.deltaYHint = wheel_event.deltaY;
   if (wheel_event.scrollByPage) {
     begin_event.data.scrollBegin.deltaHintUnits = blink::WebGestureEvent::Page;
     if (begin_event.data.scrollBegin.deltaXHint) {
       begin_event.data.scrollBegin.deltaXHint =
           begin_event.data.scrollBegin.deltaXHint > 0 ? 1 : -1;
     }
     if (begin_event.data.scrollBegin.deltaYHint) {
       begin_event.data.scrollBegin.deltaYHint =
           begin_event.data.scrollBegin.deltaYHint > 0 ? 1 : -1;
     }
   } else {
     begin_event.data.scrollBegin.deltaHintUnits =
         wheel_event.hasPreciseScrollingDeltas
             ? blink::WebGestureEvent::PrecisePixels
             : blink::WebGestureEvent::Pixels;
   }
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
 
   HandleInputEventOnViewOrPopup(begin_event);
 
   WebGestureEvent update_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollUpdate,
-                                 GetCurrentEventTimeSec(), wheel_event,
+                                 GetMockTimeSeconds(), wheel_event,
                                  &update_event);
   update_event.data.scrollUpdate.deltaX =
       begin_event.data.scrollBegin.deltaXHint;
   update_event.data.scrollUpdate.deltaY =
       begin_event.data.scrollBegin.deltaYHint;
   update_event.data.scrollUpdate.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(update_event);
 
   WebGestureEvent end_event;
   InitGestureEventFromMouseWheel(WebInputEvent::GestureScrollEnd,
-                                 GetCurrentEventTimeSec(), wheel_event,
+                                 GetMockTimeSeconds(), wheel_event,
                                  &end_event);
   end_event.data.scrollEnd.deltaUnits =
       begin_event.data.scrollBegin.deltaHintUnits;
 
   if (force_layout_on_events_)
     view()->updateAllLifecyclePhases();
   HandleInputEventOnViewOrPopup(end_event);
 }
 
 TestInterfaces* EventSender::interfaces() {
@@ skipping 13 matching lines @@
 }
 
 std::unique_ptr<WebInputEvent> EventSender::ScaleEvent(
     const WebInputEvent& event) {
   // ui::ScaleWebInputEvent returns nullptr when the scale is 1.0f as the event
   // does not have to be converted.
   return ui::ScaleWebInputEvent(event, delegate()->GetWindowToViewportScale());
 }
 
 }  // namespace test_runner