Refactor Scroll Customization to share cc::ScrollStateData with blink.

ui/events/blink/input_handler_proxy.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 "ui/events/blink/input_handler_proxy.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 105 matching lines @@
 
 WebGestureEvent ObtainGestureScrollBegin(const WebGestureEvent& event) {
   WebGestureEvent scroll_begin_event = event;
   scroll_begin_event.type = WebInputEvent::GestureScrollBegin;
   scroll_begin_event.data.scrollBegin.deltaXHint = 0;
   scroll_begin_event.data.scrollBegin.deltaYHint = 0;
   return scroll_begin_event;
 }
 
 cc::ScrollState CreateScrollStateForGesture(const WebGestureEvent& event) {
+  cc::ScrollStateData scroll_state_data;
   switch (event.type) {
     case WebInputEvent::GestureScrollBegin:
-      return cc::ScrollState(0, 0, event.x, event.y, 0, 0, true, false, false);
+      scroll_state_data.start_position_x = event.x;
+      scroll_state_data.start_position_y = event.y;
+      scroll_state_data.is_beginning = true;
+      break;
     case WebInputEvent::GestureFlingStart:
-      return cc::ScrollState(
-          0, 0, event.x, event.y, event.data.flingStart.velocityX,
-          event.data.flingStart.velocityX, true, true, false);
+      scroll_state_data.velocity_x = event.data.flingStart.velocityX;
+      scroll_state_data.velocity_y = event.data.flingStart.velocityY;
+      scroll_state_data.is_in_inertial_phase = true;
+      break;
     case WebInputEvent::GestureScrollUpdate:
-      return cc::ScrollState(-event.data.scrollUpdate.deltaX,
-                             -event.data.scrollUpdate.deltaY, event.x, event.y,
-                             event.data.scrollUpdate.velocityX,
-                             event.data.scrollUpdate.velocityY,
-                             event.data.scrollUpdate.inertial, false, false);
+      scroll_state_data.delta_x = -event.data.scrollUpdate.deltaX;
+      scroll_state_data.delta_y = -event.data.scrollUpdate.deltaY;
+      scroll_state_data.velocity_x = event.data.scrollUpdate.velocityX;
+      scroll_state_data.velocity_y = event.data.scrollUpdate.velocityY;
+      scroll_state_data.is_in_inertial_phase = event.data.scrollUpdate.inertial;
+      break;
     case WebInputEvent::GestureScrollEnd:
-      return cc::ScrollState(0, 0, event.x, event.y, 0, 0, false, false, true);
     case WebInputEvent::GestureFlingCancel:
-      return cc::ScrollState(0, 0, event.x, event.y, 0, 0, false, true, true);
-
+      scroll_state_data.is_ending = true;
+      break;
     default:
       NOTREACHED();
-      return cc::ScrollState(0, 0, 0, 0, 0, 0, false, false, false);
+      break;
   }
+  return cc::ScrollState(scroll_state_data);
 }
 
 void ReportInputEventLatencyUma(const WebInputEvent& event,
                                 const ui::LatencyInfo& latency_info) {
   if (!(event.type == WebInputEvent::GestureScrollBegin ||
         event.type == WebInputEvent::GestureScrollUpdate ||
         event.type == WebInputEvent::GesturePinchBegin ||
         event.type == WebInputEvent::GesturePinchUpdate ||
         event.type == WebInputEvent::GestureFlingStart)) {
     return;
@@ skipping 299 matching lines @@
         result = DID_HANDLE;
         break;
       case cc::InputHandler::SCROLL_IGNORED:
         result = DROP_EVENT;
         break;
       default:
         result = DID_NOT_HANDLE;
         break;
     }
   } else {
-    cc::ScrollState scroll_state_begin(0, 0, wheel_event.x, wheel_event.y, 0, 0,
-                                       true, false, false);
+    cc::ScrollStateData scroll_state_begin_data;
+    scroll_state_begin_data.start_position_x = wheel_event.x;
+    scroll_state_begin_data.start_position_y = wheel_event.y;
+    scroll_state_begin_data.is_beginning = true;
+    cc::ScrollState scroll_state_begin(scroll_state_begin_data);
     cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
         &scroll_state_begin, cc::InputHandler::WHEEL);
 
     RecordMainThreadScrollingReasons(
         wheel_event.type, scroll_status.main_thread_scrolling_reasons);
 
     switch (scroll_status.thread) {
       case cc::InputHandler::SCROLL_ON_IMPL_THREAD: {
         TRACE_EVENT_INSTANT2("input",
                              "InputHandlerProxy::handle_input wheel scroll",
                              TRACE_EVENT_SCOPE_THREAD, "deltaX",
                              scroll_delta.x(), "deltaY", scroll_delta.y());
-        cc::ScrollState scroll_state_update(scroll_delta.x(), scroll_delta.y(),
-                                            wheel_event.x, wheel_event.y, 0, 0,
-                                            false, false, false);
+
+        cc::ScrollStateData scroll_state_update_data;
+        scroll_state_update_data.delta_x = scroll_delta.x();
+        scroll_state_update_data.delta_y = scroll_delta.y();
+        scroll_state_update_data.start_position_x = wheel_event.x;
+        scroll_state_update_data.start_position_y = wheel_event.y;
+        cc::ScrollState scroll_state_update(scroll_state_update_data);
 
         scroll_result = input_handler_->ScrollBy(&scroll_state_update);
         HandleOverscroll(gfx::Point(wheel_event.x, wheel_event.y),
                          scroll_result);
 
-        cc::ScrollState scroll_state_end(0, 0, wheel_event.x, wheel_event.y,
-                                         0, 0, false, false, true);
+        cc::ScrollStateData scroll_state_end_data;
+        scroll_state_end_data.is_ending = true;
+        cc::ScrollState scroll_state_end(scroll_state_end_data);
         input_handler_->ScrollEnd(&scroll_state_end);
 
         result = scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
         break;
       }
       case cc::InputHandler::SCROLL_IGNORED:
         // TODO(jamesr): This should be DROP_EVENT, but in cases where we fail
         // to properly sync scrollability it's safer to send the event to the
         // main thread. Change back to DROP_EVENT once we have synchronization
         // bugs sorted out.
@@ skipping 518 matching lines @@
     client_->DidStopFlinging();
     return true;
   }
   return false;
 }
 
 bool InputHandlerProxy::CancelCurrentFlingWithoutNotifyingClient() {
   bool had_fling_animation = !!fling_curve_;
   if (had_fling_animation &&
       fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchscreen) {
-    cc::ScrollState scroll_state(0, 0, fling_parameters_.point.x,
-                                 fling_parameters_.point.y, 0, 0, false, true,
-                                 true);
+    cc::ScrollStateData scroll_state_data;
+    scroll_state_data.is_ending = true;
+    cc::ScrollState scroll_state(scroll_state_data);
     input_handler_->ScrollEnd(&scroll_state);
     TRACE_EVENT_ASYNC_END0(
         "input",
         "InputHandlerProxy::HandleGestureFling::started",
         this);
   }
 
   TRACE_EVENT_INSTANT1("input",
                        "InputHandlerProxy::CancelCurrentFling",
                        TRACE_EVENT_SCOPE_THREAD,
@@ skipping 99 matching lines @@
                clipped_increment.height);
 
   bool did_scroll = false;
 
   switch (fling_parameters_.sourceDevice) {
     case blink::WebGestureDeviceTouchpad:
       did_scroll = TouchpadFlingScroll(clipped_increment);
       break;
     case blink::WebGestureDeviceTouchscreen: {
       clipped_increment = ToClientScrollIncrement(clipped_increment);
-      cc::ScrollState scroll_state(
-          clipped_increment.width, clipped_increment.height,
-          fling_parameters_.point.x, fling_parameters_.point.y,
-          clipped_velocity.width, clipped_velocity.height, false, true, false);
+      cc::ScrollStateData scroll_state_data;
+      scroll_state_data.delta_x = clipped_increment.width;
+      scroll_state_data.delta_y = clipped_increment.height;
+      scroll_state_data.velocity_x = clipped_velocity.width;
+      scroll_state_data.velocity_y = clipped_velocity.height;
+      scroll_state_data.is_in_inertial_phase = true;
+      cc::ScrollState scroll_state(scroll_state_data);
       cc::InputHandlerScrollResult scroll_result =
           input_handler_->ScrollBy(&scroll_state);
       HandleOverscroll(fling_parameters_.point, scroll_result);
       did_scroll = scroll_result.did_scroll;
     } break;
     case blink::WebGestureDeviceUninitialized:
       NOTREACHED();
       return false;
   }
 
   if (did_scroll) {
     fling_parameters_.cumulativeScroll.width += clipped_increment.width;
     fling_parameters_.cumulativeScroll.height += clipped_increment.height;
   }
 
   // It's possible the provided |increment| is sufficiently small as to not
   // trigger a scroll, e.g., with a trivial time delta between fling updates.
   // Return true in this case to prevent early fling termination.
   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
       std::abs(clipped_increment.height) < kScrollEpsilon)
     return true;
 
   return did_scroll;
 }
 
 }  // namespace ui