gpu benchmarking swipe for touchpad

content/browser/renderer_host/input/synthetic_gesture_target_aura.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 "content/browser/renderer_host/input/synthetic_gesture_target_aura.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/events/event_sink.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/gesture_detection/gesture_configuration.h"
 
 using blink::WebTouchEvent;
 using blink::WebMouseWheelEvent;
+using blink::WebGestureEvent;
 
 namespace content {
 
 SyntheticGestureTargetAura::SyntheticGestureTargetAura(
     RenderWidgetHostImpl* host)
     : SyntheticGestureTargetBase(host) {
   ScreenInfo screen_info;
   host->GetScreenInfo(&screen_info);
   device_scale_factor_ = screen_info.device_scale_factor;
 }
@@ skipping 27 matching lines @@
     ui::EventDispatchDetails details =
         host->event_sink()->OnEventFromSource(event.get());
     if (details.dispatcher_destroyed)
       break;
   }
 }
 
 void SyntheticGestureTargetAura::DispatchWebMouseWheelEventToPlatform(
       const blink::WebMouseWheelEvent& web_wheel,
       const ui::LatencyInfo&) {
+  base::TimeTicks timestamp =
+      ui::EventTimeStampFromSeconds(web_wheel.TimeStampSeconds());
   ui::MouseWheelEvent wheel_event(
       gfx::Vector2d(web_wheel.delta_x, web_wheel.delta_y), gfx::Point(),
-      gfx::Point(), ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
+      gfx::Point(), timestamp, ui::EF_NONE, ui::EF_NONE);
   gfx::PointF location(web_wheel.PositionInWidget().x * device_scale_factor_,
                        web_wheel.PositionInWidget().y * device_scale_factor_);
   wheel_event.set_location_f(location);
   wheel_event.set_root_location_f(location);
 
   aura::Window* window = GetWindow();
   wheel_event.ConvertLocationToTarget(window, window->GetRootWindow());
   ui::EventDispatchDetails details =
       window->GetHost()->event_sink()->OnEventFromSource(&wheel_event);
   if (details.dispatcher_destroyed)
@@ skipping 78 matching lines @@
   mouse_event.set_root_location_f(location);
 
   aura::Window* window = GetWindow();
   mouse_event.ConvertLocationToTarget(window, window->GetRootWindow());
   ui::EventDispatchDetails details =
       window->GetHost()->event_sink()->OnEventFromSource(&mouse_event);
   if (details.dispatcher_destroyed)
     return;
 }
 
+// This function generates a synthetic ui event which aligns with ChromeOS
+// event stream for handling touchpad fling.
+void SyntheticGestureTargetAura::DispatchTouchpadGestureFlingStartToPlatform(
+    const blink::WebGestureEvent& web_gesture,
+    const ui::LatencyInfo& latency_info) {
+  DCHECK_EQ(web_gesture.GetType(), blink::WebInputEvent::kGestureFlingStart);
+
+  float velocity_x = web_gesture.data.fling_start.velocity_x;
+  float velocity_y = web_gesture.data.fling_start.velocity_y;
+  DCHECK(velocity_x || velocity_y);
+
+  base::TimeTicks timestamp =
+      ui::EventTimeStampFromSeconds(web_gesture.TimeStampSeconds());
+  ui::ScrollEvent fling_event(ui::ET_SCROLL_FLING_START, gfx::Point(),
+                              timestamp, ui::EF_NONE, velocity_x, velocity_y,
+                              velocity_x, velocity_y,
+                              2);  // finger_count
+  gfx::PointF location(web_gesture.x * device_scale_factor_,
+                       web_gesture.y * device_scale_factor_);
+  fling_event.set_location_f(location);
+  fling_event.set_root_location_f(location);
+
+  aura::Window* window = GetWindow();
+  fling_event.ConvertLocationToTarget(window, window->GetRootWindow());
+  ui::EventDispatchDetails details =
+      window->GetHost()->event_sink()->OnEventFromSource(&fling_event);
+  if (details.dispatcher_destroyed)
+    return;
+}
+
 SyntheticGestureParams::GestureSourceType
 SyntheticGestureTargetAura::GetDefaultSyntheticGestureSourceType() const {
   return SyntheticGestureParams::TOUCH_INPUT;
 }
 
 float SyntheticGestureTargetAura::GetTouchSlopInDips() const {
   // - 1 because Aura considers a pointer to be moving if it has moved at least
   // 'max_touch_move_in_pixels_for_click' pixels.
   return ui::GestureConfiguration::GetInstance()
              ->max_touch_move_in_pixels_for_click() -
          1;
 }
 
 float SyntheticGestureTargetAura::GetMinScalingSpanInDips() const {
   return ui::GestureConfiguration::GetInstance()
       ->min_distance_for_pinch_scroll_in_pixels();
 }
 
 aura::Window* SyntheticGestureTargetAura::GetWindow() const {
   aura::Window* window = render_widget_host()->GetView()->GetNativeView();
   DCHECK(window);
   return window;
 }
 
 }  // namespace content