Add timestamps to synthesized events.

content/browser/renderer_host/input/synthetic_gesture_controller_unittest.cc

 // Copyright 2013 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 "base/time/time.h"
 #include "content/browser/renderer_host/input/synthetic_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_controller.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target.h"
 #include "content/browser/renderer_host/input/synthetic_pinch_gesture.h"
@@ skipping 25 matching lines @@
 class MockSyntheticGesture : public SyntheticGesture {
  public:
   MockSyntheticGesture(bool* finished, int num_steps)
       : finished_(finished),
         num_steps_(num_steps),
         step_count_(0) {
     *finished_ = false;
   }
   virtual ~MockSyntheticGesture() {}
 
-  virtual Result ForwardInputEvents(const base::TimeDelta& interval,
+  virtual Result ForwardInputEvents(const base::TimeTicks& timestamp,
                                     SyntheticGestureTarget* target) OVERRIDE {
     step_count_++;
     if (step_count_ == num_steps_) {
       *finished_ = true;
       return SyntheticGesture::GESTURE_FINISHED;
     } else if (step_count_ > num_steps_) {
       *finished_ = true;
       // Return arbitrary failure.
       return SyntheticGesture::GESTURE_SOURCE_TYPE_NOT_IMPLEMENTED;
     }
@@ skipping 207 matching lines @@
   bool started_;
 };
 
 class MockSyntheticTapGestureTarget : public MockSyntheticGestureTarget {
  public:
   MockSyntheticTapGestureTarget() : state_(NOT_STARTED) {}
   virtual ~MockSyntheticTapGestureTarget() {}
 
   bool GestureFinished() const { return state_ == FINISHED; }
   gfx::Point position() const { return position_; }
+  base::TimeDelta GetDuration() const { return stop_time_ - start_time_; }
 
  protected:
   enum GestureState {
     NOT_STARTED,
     STARTED,
     FINISHED
   };
 
   gfx::Point position_;
+  base::TimeDelta start_time_;
+  base::TimeDelta stop_time_;
   GestureState state_;
 };
 
 class MockSyntheticTapTouchTarget : public MockSyntheticTapGestureTarget {
  public:
   MockSyntheticTapTouchTarget() {}
   virtual ~MockSyntheticTapTouchTarget() {}
 
   virtual void DispatchInputEventToPlatform(const InputEvent& event) OVERRIDE {
     const blink::WebInputEvent* web_event = event.web_event.get();
     ASSERT_TRUE(blink::WebInputEvent::isTouchEventType(web_event->type));
     const blink::WebTouchEvent* touch_event =
         static_cast<const blink::WebTouchEvent*>(web_event);
     ASSERT_EQ(touch_event->touchesLength, (unsigned int)1);
 
     switch (state_) {
       case NOT_STARTED:
         EXPECT_EQ(touch_event->type, blink::WebInputEvent::TouchStart);
         position_ = gfx::Point(touch_event->touches[0].position);
+        start_time_ = base::TimeDelta::FromMilliseconds(
+            static_cast<int64>(touch_event->timeStampSeconds * 1000));
         state_ = STARTED;
         break;
       case STARTED:
         EXPECT_EQ(touch_event->type, blink::WebInputEvent::TouchEnd);
         EXPECT_EQ(position_, gfx::Point(touch_event->touches[0].position));
+        stop_time_ = base::TimeDelta::FromMilliseconds(
+            static_cast<int64>(touch_event->timeStampSeconds * 1000));
         state_ = FINISHED;
         break;
       case FINISHED:
         EXPECT_FALSE(true);
         break;
     }
   }
 };
 
 class MockSyntheticTapMouseTarget : public MockSyntheticTapGestureTarget {
  public:
   MockSyntheticTapMouseTarget() {}
   virtual ~MockSyntheticTapMouseTarget() {}
 
   virtual void DispatchInputEventToPlatform(const InputEvent& event) OVERRIDE {
     const blink::WebInputEvent* web_event = event.web_event.get();
     ASSERT_TRUE(blink::WebInputEvent::isMouseEventType(web_event->type));
     const blink::WebMouseEvent* mouse_event =
         static_cast<const blink::WebMouseEvent*>(web_event);
 
     switch (state_) {
       case NOT_STARTED:
         EXPECT_EQ(mouse_event->type, blink::WebInputEvent::MouseDown);
         EXPECT_EQ(mouse_event->button, blink::WebMouseEvent::ButtonLeft);
         EXPECT_EQ(mouse_event->clickCount, 1);
         position_ = gfx::Point(mouse_event->x, mouse_event->y);
+        start_time_ = base::TimeDelta::FromMilliseconds(
+            static_cast<int64>(mouse_event->timeStampSeconds * 1000));
         state_ = STARTED;
         break;
       case STARTED:
         EXPECT_EQ(mouse_event->type, blink::WebInputEvent::MouseUp);
         EXPECT_EQ(mouse_event->button, blink::WebMouseEvent::ButtonLeft);
         EXPECT_EQ(mouse_event->clickCount, 1);
         EXPECT_EQ(position_, gfx::Point(mouse_event->x, mouse_event->y));
+        stop_time_ = base::TimeDelta::FromMilliseconds(
+            static_cast<int64>(mouse_event->timeStampSeconds * 1000));
         state_ = FINISHED;
         break;
       case FINISHED:
         EXPECT_FALSE(true);
         break;
     }
   }
 };
 
 class SyntheticGestureControllerTest : public testing::Test {
@@ skipping 426 matching lines @@
   scoped_ptr<SyntheticTapGesture> gesture(new SyntheticTapGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   FlushInputUntilComplete();
 
   MockSyntheticTapTouchTarget* tap_target =
       static_cast<MockSyntheticTapTouchTarget*>(target_);
   EXPECT_EQ(1, target_->num_success());
   EXPECT_EQ(0, target_->num_failure());
   EXPECT_TRUE(tap_target->GestureFinished());
   EXPECT_EQ(tap_target->position(), params.position);
+  EXPECT_EQ(tap_target->GetDuration().InMilliseconds(), params.duration_ms);
   EXPECT_GE(GetTotalTime(),
             base::TimeDelta::FromMilliseconds(params.duration_ms));
 }
 
 TEST_F(SyntheticGestureControllerTest, TapGestureMouse) {
   CreateControllerAndTarget<MockSyntheticTapMouseTarget>();
 
   SyntheticTapGestureParams params;
   params.gesture_source_type = SyntheticGestureParams::MOUSE_INPUT;
   params.duration_ms = 79;
   params.position.SetPoint(98, 123);
 
   scoped_ptr<SyntheticTapGesture> gesture(new SyntheticTapGesture(params));
   controller_->QueueSyntheticGesture(gesture.PassAs<SyntheticGesture>());
   FlushInputUntilComplete();
 
   MockSyntheticTapMouseTarget* tap_target =
       static_cast<MockSyntheticTapMouseTarget*>(target_);
   EXPECT_EQ(1, target_->num_success());
   EXPECT_EQ(0, target_->num_failure());
   EXPECT_TRUE(tap_target->GestureFinished());
   EXPECT_EQ(tap_target->position(), params.position);
+  EXPECT_EQ(tap_target->GetDuration().InMilliseconds(), params.duration_ms);
   EXPECT_GE(GetTotalTime(),
             base::TimeDelta::FromMilliseconds(params.duration_ms));
 }
 
 }  // namespace
 
 }  // namespace content