Generate proper LatencyInfo components for synthetic gestures

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"
 #include "content/browser/renderer_host/input/synthetic_smooth_scroll_gesture.h"
 #include "content/browser/renderer_host/input/synthetic_tap_gesture.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
-#include "content/common/input/input_event.h"
 #include "content/common/input/synthetic_pinch_gesture_params.h"
 #include "content/common/input/synthetic_smooth_scroll_gesture_params.h"
 #include "content/common/input/synthetic_tap_gesture_params.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/test/test_render_view_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/point_f.h"
 #include "ui/gfx/vector2d.h"
 #include "ui/gfx/vector2d_f.h"
 
+using blink::WebInputEvent;
+using blink::WebMouseEvent;
+using blink::WebMouseWheelEvent;
+using blink::WebTouchEvent;
+
 namespace content {
 
 namespace {
 
 const int kFlushInputRateInMs = 16;
 const int kPointerAssumedStoppedTimeMs = 43;
 const int kTouchSlopInDips = 7;
 
 class MockSyntheticGesture : public SyntheticGesture {
  public:
@@ skipping 29 matching lines @@
 class MockSyntheticGestureTarget : public SyntheticGestureTarget {
  public:
   MockSyntheticGestureTarget()
       : num_success_(0),
         num_failure_(0),
         flush_requested_(false),
         pointer_assumed_stopped_time_ms_(kPointerAssumedStoppedTimeMs) {}
   virtual ~MockSyntheticGestureTarget() {}
 
   // SyntheticGestureTarget:
-  virtual void DispatchInputEventToPlatform(const InputEvent& event) OVERRIDE {}
+  virtual void DispatchInputEventToPlatform(
+      const WebInputEvent& event) OVERRIDE {}
 
   virtual void OnSyntheticGestureCompleted(
       SyntheticGesture::Result result) OVERRIDE {
     DCHECK_NE(result, SyntheticGesture::GESTURE_RUNNING);
     if (result == SyntheticGesture::GESTURE_FINISHED)
       num_success_++;
     else
       num_failure_++;
   }
 
@@ skipping 49 matching lines @@
  protected:
   gfx::Vector2dF scroll_distance_;
 };
 
 class MockSyntheticSmoothScrollMouseTarget
     : public MockSyntheticSmoothScrollGestureTarget {
  public:
   MockSyntheticSmoothScrollMouseTarget() {}
   virtual ~MockSyntheticSmoothScrollMouseTarget() {}
 
-  virtual void DispatchInputEventToPlatform(const InputEvent& event) OVERRIDE {
-    const blink::WebInputEvent* web_event = event.web_event.get();
-    ASSERT_EQ(web_event->type, blink::WebInputEvent::MouseWheel);
-    const blink::WebMouseWheelEvent* mouse_wheel_event =
-        static_cast<const blink::WebMouseWheelEvent*>(web_event);
-    scroll_distance_ -= gfx::Vector2dF(mouse_wheel_event->deltaX,
-                                       mouse_wheel_event->deltaY);
+  virtual void DispatchInputEventToPlatform(
+      const WebInputEvent& event) OVERRIDE {
+    ASSERT_EQ(event.type, WebInputEvent::MouseWheel);
+    const WebMouseWheelEvent& mouse_wheel_event =
+        static_cast<const WebMouseWheelEvent&>(event);
+    scroll_distance_ -= gfx::Vector2dF(mouse_wheel_event.deltaX,
+                                       mouse_wheel_event.deltaY);
   }
 };
 
 class MockSyntheticSmoothScrollTouchTarget
     : public MockSyntheticSmoothScrollGestureTarget {
  public:
   MockSyntheticSmoothScrollTouchTarget()
       : started_(false) {}
   virtual ~MockSyntheticSmoothScrollTouchTarget() {}
 
-  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);
+  virtual void DispatchInputEventToPlatform(
+      const WebInputEvent& event) OVERRIDE {
+    ASSERT_TRUE(WebInputEvent::isTouchEventType(event.type));
+    const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
+    ASSERT_EQ(touch_event.touchesLength, 1U);
 
     if (!started_) {
-      ASSERT_EQ(touch_event->type, blink::WebInputEvent::TouchStart);
-      anchor_.SetPoint(touch_event->touches[0].position.x,
-                       touch_event->touches[0].position.y);
+      ASSERT_EQ(touch_event.type, WebInputEvent::TouchStart);
+      anchor_.SetPoint(touch_event.touches[0].position.x,
+                       touch_event.touches[0].position.y);
       started_ = true;
     } else {
-      ASSERT_NE(touch_event->type, blink::WebInputEvent::TouchStart);
-      ASSERT_NE(touch_event->type, blink::WebInputEvent::TouchCancel);
+      ASSERT_NE(touch_event.type, WebInputEvent::TouchStart);
+      ASSERT_NE(touch_event.type, WebInputEvent::TouchCancel);
       // Ignore move events.
 
-      if (touch_event->type == blink::WebInputEvent::TouchEnd)
+      if (touch_event.type == WebInputEvent::TouchEnd)
         scroll_distance_ =
-            anchor_ - gfx::PointF(touch_event->touches[0].position.x,
-                                  touch_event->touches[0].position.y);
+            anchor_ - gfx::PointF(touch_event.touches[0].position.x,
+                                  touch_event.touches[0].position.y);
     }
   }
 
  protected:
   gfx::Point anchor_;
   bool started_;
 };
 
 class MockSyntheticPinchTouchTarget : public MockSyntheticGestureTarget {
  public:
   enum ZoomDirection {
     ZOOM_DIRECTION_UNKNOWN,
     ZOOM_IN,
     ZOOM_OUT
   };
 
   MockSyntheticPinchTouchTarget()
       : total_num_pixels_covered_(0),
         last_pointer_distance_(0),
         zoom_direction_(ZOOM_DIRECTION_UNKNOWN),
         started_(false) {}
   virtual ~MockSyntheticPinchTouchTarget() {}
 
-  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)2);
+  virtual void DispatchInputEventToPlatform(
+      const WebInputEvent& event) OVERRIDE {
+    ASSERT_TRUE(WebInputEvent::isTouchEventType(event.type));
+    const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
+    ASSERT_EQ(touch_event.touchesLength, 2U);
 
     if (!started_) {
-      ASSERT_EQ(touch_event->type, blink::WebInputEvent::TouchStart);
+      ASSERT_EQ(touch_event.type, WebInputEvent::TouchStart);
 
-      start_0_ = gfx::Point(touch_event->touches[0].position);
-      start_1_ = gfx::Point(touch_event->touches[1].position);
+      start_0_ = gfx::Point(touch_event.touches[0].position);
+      start_1_ = gfx::Point(touch_event.touches[1].position);
       last_pointer_distance_ = (start_0_ - start_1_).Length();
 
       started_ = true;
     } else {
-      ASSERT_NE(touch_event->type, blink::WebInputEvent::TouchStart);
-      ASSERT_NE(touch_event->type, blink::WebInputEvent::TouchCancel);
+      ASSERT_NE(touch_event.type, WebInputEvent::TouchStart);
+      ASSERT_NE(touch_event.type, WebInputEvent::TouchCancel);
 
-      gfx::PointF current_0 = gfx::Point(touch_event->touches[0].position);
-      gfx::PointF current_1 = gfx::Point(touch_event->touches[1].position);
+      gfx::PointF current_0 = gfx::Point(touch_event.touches[0].position);
+      gfx::PointF current_1 = gfx::Point(touch_event.touches[1].position);
 
       total_num_pixels_covered_ =
           (current_0 - start_0_).Length() + (current_1 - start_1_).Length();
       float pointer_distance = (current_0 - current_1).Length();
 
       if (last_pointer_distance_ != pointer_distance) {
         if (zoom_direction_ == ZOOM_DIRECTION_UNKNOWN)
           zoom_direction_ =
               ComputeZoomDirection(last_pointer_distance_, pointer_distance);
         else
@@ skipping 45 matching lines @@
   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);
+  virtual void DispatchInputEventToPlatform(
+        const WebInputEvent& event) OVERRIDE {
+    ASSERT_TRUE(WebInputEvent::isTouchEventType(event.type));
+    const WebTouchEvent& touch_event = static_cast<const WebTouchEvent&>(event);
+    ASSERT_EQ(touch_event.touchesLength, 1U);
 
     switch (state_) {
       case NOT_STARTED:
-        EXPECT_EQ(touch_event->type, blink::WebInputEvent::TouchStart);
-        position_ = gfx::Point(touch_event->touches[0].position);
+        EXPECT_EQ(touch_event.type, WebInputEvent::TouchStart);
+        position_ = gfx::Point(touch_event.touches[0].position);
         start_time_ = base::TimeDelta::FromMilliseconds(
-            static_cast<int64>(touch_event->timeStampSeconds * 1000));
+            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));
+        EXPECT_EQ(touch_event.type, WebInputEvent::TouchEnd);
+        EXPECT_EQ(position_, gfx::Point(touch_event.touches[0].position));
         stop_time_ = base::TimeDelta::FromMilliseconds(
-            static_cast<int64>(touch_event->timeStampSeconds * 1000));
+            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);
+  virtual void DispatchInputEventToPlatform(
+        const WebInputEvent& event) OVERRIDE {
+    ASSERT_TRUE(WebInputEvent::isMouseEventType(event.type));
+    const WebMouseEvent& mouse_event = static_cast<const WebMouseEvent&>(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);
+        EXPECT_EQ(mouse_event.type, WebInputEvent::MouseDown);
+        EXPECT_EQ(mouse_event.button, 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));
+            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));
+        EXPECT_EQ(mouse_event.type, WebInputEvent::MouseUp);
+        EXPECT_EQ(mouse_event.button, 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));
+            static_cast<int64>(mouse_event.timeStampSeconds * 1000));
         state_ = FINISHED;
         break;
       case FINISHED:
         EXPECT_FALSE(true);
         break;
     }
   }
 };
 
 class SyntheticGestureControllerTest : public testing::Test {
@@ skipping 457 matching lines @@
   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