Implement Wheel Gesture Scrolling on OSX.

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 602 matching lines @@
     scroll_status =
         input_handler_->ScrollBegin(&scroll_state, cc::InputHandler::GESTURE);
   }
   UMA_HISTOGRAM_ENUMERATION("Renderer4.CompositorScrollHitTestResult",
                             scroll_status.thread,
                             cc::InputHandler::LAST_SCROLL_STATUS + 1);
 
   RecordMainThreadScrollingReasons(gesture_event.type,
                                    scroll_status.main_thread_scrolling_reasons);
 
+  InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
   switch (scroll_status.thread) {
     case cc::InputHandler::SCROLL_ON_IMPL_THREAD:
       TRACE_EVENT_INSTANT0("input",
                            "InputHandlerProxy::handle_input gesture scroll",
                            TRACE_EVENT_SCOPE_THREAD);
       gesture_scroll_on_impl_thread_ = true;
-      return DID_HANDLE;
+      result = DID_HANDLE;
+      break;
     case cc::InputHandler::SCROLL_UNKNOWN:
     case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
-      return DID_NOT_HANDLE;
+      result = DID_NOT_HANDLE;
+      break;
     case cc::InputHandler::SCROLL_IGNORED:
-      return DROP_EVENT;
+      result = DROP_EVENT;
+      break;
   }
-  return DID_NOT_HANDLE;
+  // Send the event and its disposition to the elasticity controller to update
+  // the over-scroll animation. If the event is to be handled on the main
+  // thread, the event and its disposition will be sent to the elasticity
+  // controller after being handled on the main thread.
+  if (scroll_elasticity_controller_ && result != DID_NOT_HANDLE) {
+    // Note that the call to the elasticity controller is made asynchronously,
+    // to minimize divergence between main thread and impl thread event
+    // handling paths.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &InputScrollElasticityController::ObserveGestureEventAndResult,
+            scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
+            cc::InputHandlerScrollResult()));
+  }
+
+  return result;
 }
 
 InputHandlerProxy::EventDisposition
 InputHandlerProxy::HandleGestureScrollUpdate(
   const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
   DCHECK(expect_scroll_update_end_);
 #endif
   if (!gesture_scroll_on_impl_thread_ && !gesture_pinch_on_impl_thread_)
     return DID_NOT_HANDLE;
@@ skipping 11 matching lines @@
         return DID_HANDLE;
       case cc::InputHandler::SCROLL_IGNORED:
         return DROP_EVENT;
       default:
         return DID_NOT_HANDLE;
     }
   }
   cc::InputHandlerScrollResult scroll_result =
       input_handler_->ScrollBy(&scroll_state);
   HandleOverscroll(scroll_point, scroll_result);
+
+  // Send the event and its disposition to the elasticity controller to update
+  // the over-scroll animation.
+  if (scroll_elasticity_controller_) {
+    // Note that the call to the elasticity controller is made asynchronously,
+    // to minimize divergence between main thread and impl thread event
+    // handling paths.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(

[tdresser, 2016/03/02 18:26:53]

Can we share this logic with HandleGestureScrollBegin/End?

[dtapuska, 2016/03/07 18:03:59]

Done.

+        FROM_HERE,
+        base::Bind(
+            &InputScrollElasticityController::ObserveGestureEventAndResult,
+            scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
+            scroll_result));
+  }
+
   return scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollEnd(
   const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
   DCHECK(expect_scroll_update_end_);
   expect_scroll_update_end_ = false;
 #endif
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   input_handler_->ScrollEnd(&scroll_state);
   if (!gesture_scroll_on_impl_thread_)
     return DID_NOT_HANDLE;
+
+  // Send the event and its disposition to the elasticity controller to update
+  // the over-scroll animation. If the event is to be handled on the main
+  // thread, the event and its disposition will be sent to the elasticity
+  // controller after being handled on the main thread.
+  if (scroll_elasticity_controller_) {
+    // Note that the call to the elasticity controller is made asynchronously,
+    // to minimize divergence between main thread and impl thread event
+    // handling paths.
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &InputScrollElasticityController::ObserveGestureEventAndResult,
+            scroll_elasticity_controller_->GetWeakPtr(), gesture_event,
+            cc::InputHandlerScrollResult()));
+  }
+
   gesture_scroll_on_impl_thread_ = false;
   return DID_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureFlingStart(
     const WebGestureEvent& gesture_event) {
   cc::ScrollState scroll_state = CreateScrollStateForGesture(gesture_event);
   cc::InputHandler::ScrollStatus scroll_status;
   scroll_status.main_thread_scrolling_reasons =
       cc::MainThreadScrollingReason::kNotScrollingOnMain;
@@ skipping 613 matching lines @@
   // 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