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 "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_processor.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 28 matching lines @@
     ui::EventDispatchDetails details =
         host->event_processor()->OnEventFromSource(*iter);
     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.deltaX, web_wheel.deltaY), gfx::Point(),
-      gfx::Point(), ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
+      gfx::Point(), timestamp, ui::EF_NONE, ui::EF_NONE);

[bokan, 2017/03/10 14:41:57]

Is this change related?

[sahel, 2017/03/10 21:51:41]

Yes, it is. It used to use eventTimeForNow instead of the event timestamp.
Because SyntheticSmoothMoveGesture::ForwardMouseWheelInputEvents used to call
itself recursively with the same timestamp. The result was receiving synthetic
wheel events at the same time.

I had to make sure that wheel events are generated with different timestamps and
the fling is sent after mouse wheels (similar to touch). Because otherwise fling
would have been handled before GSB that was generated because of handling the
first wheel event.

[bokan, 2017/03/13 13:43:13]

Acknowledged.

   gfx::PointF location(web_wheel.x * device_scale_factor_,
                        web_wheel.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_processor()->OnEventFromSource(&wheel_event);
   if (details.dispatcher_destroyed)
@@ skipping 74 matching lines @@
   mouse_event.set_pointer_details(pointer_details);
 
   aura::Window* window = GetWindow();
   mouse_event.ConvertLocationToTarget(window, window->GetRootWindow());
   ui::EventDispatchDetails details =
       window->GetHost()->event_processor()->OnEventFromSource(&mouse_event);
   if (details.dispatcher_destroyed)
     return;
 }
 
+void SyntheticGestureTargetAura::DispatchTouchpadGestureFlingStartToPlatform(
+    const blink::WebGestureEvent& web_gesture,
+    const ui::LatencyInfo& latency_info) {
+  DCHECK_EQ(web_gesture.type(), blink::WebInputEvent::GestureFlingStart);
+
+  if (web_gesture.type() != blink::WebInputEvent::GestureFlingStart)

[bokan, 2017/03/10 14:41:57]

The style guide prohibits handing a failed DCHECK:
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...

Remove either the DCHECKs or the |if|s

[sahel, 2017/03/10 21:51:41]

Done.

+    return;
+
+  float velocity_x = web_gesture.data.flingStart.velocityX;
+  float velocity_y = web_gesture.data.flingStart.velocityY;
+  DCHECK(velocity_x || velocity_y);
+
+  if (!velocity_x && !velocity_y)
+    return;
+
+  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_processor()->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