Handle touchpad flings with passive event listeners on compositor thread.

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>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/events/blink/did_overscroll_params.h"
 #include "ui/events/blink/input_handler_proxy_client.h"
 #include "ui/events/blink/input_scroll_elasticity_controller.h"
+#include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/point_conversions.h"
 
 using blink::WebFloatPoint;
 using blink::WebFloatSize;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebPoint;
@@ skipping 446 matching lines @@
         return DID_NOT_HANDLE;
       case cc::EventListenerProperties::kNone:
         return DROP_EVENT;
       default:
         NOTREACHED();
         return DROP_EVENT;
     }
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::ScrollByMouseWheel(
-    const WebMouseWheelEvent& wheel_event) {
-  InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
-  cc::InputHandlerScrollResult scroll_result;
+    const WebMouseWheelEvent& wheel_event,
+    cc::EventListenerProperties listener_properties) {
+  DCHECK(listener_properties == cc::EventListenerProperties::kPassive ||
+         listener_properties == cc::EventListenerProperties::kNone);
 
   // TODO(ccameron): The rail information should be pushed down into
   // InputHandler.
   gfx::Vector2dF scroll_delta(
       wheel_event.railsMode != WebInputEvent::RailsModeVertical
           ? -wheel_event.deltaX
           : 0,
       wheel_event.railsMode != WebInputEvent::RailsModeHorizontal
           ? -wheel_event.deltaY
           : 0);
 
   if (wheel_event.scrollByPage) {
     // TODO(jamesr): We don't properly handle scroll by page in the compositor
     // thread, so punt it to the main thread. http://crbug.com/236639
-    result = DID_NOT_HANDLE;
     RecordMainThreadScrollingReasons(
         blink::WebGestureDeviceTouchpad,
         cc::MainThreadScrollingReason::kPageBasedScrolling);
+    return DID_NOT_HANDLE;
   } else {
     DCHECK(!ShouldAnimate(wheel_event.hasPreciseScrollingDeltas));
     cc::ScrollStateData scroll_state_begin_data;
     scroll_state_begin_data.position_x = wheel_event.x;
     scroll_state_begin_data.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(
         blink::WebGestureDeviceTouchpad,
         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::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.position_x = wheel_event.x;
         scroll_state_update_data.position_y = wheel_event.y;
         cc::ScrollState scroll_state_update(scroll_state_update_data);
 
-        scroll_result = input_handler_->ScrollBy(&scroll_state_update);
+        cc::InputHandlerScrollResult scroll_result =
+            input_handler_->ScrollBy(&scroll_state_update);
         HandleOverscroll(gfx::Point(wheel_event.x, wheel_event.y),
                          scroll_result, false);
 
         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;
+        if (scroll_result.did_scroll) {
+          return listener_properties == cc::EventListenerProperties::kPassive
+                     ? DID_HANDLE_NON_BLOCKING
+                     : DID_HANDLE;
+        }
+        return DROP_EVENT;
       }
       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.
-        result = DID_NOT_HANDLE;
-        break;
+        return DID_NOT_HANDLE;
       case cc::InputHandler::SCROLL_UNKNOWN:
       case cc::InputHandler::SCROLL_ON_MAIN_THREAD:
-        result = DID_NOT_HANDLE;
-        break;
+        return DID_NOT_HANDLE;
+      default:
+        NOTREACHED();
+        return DID_NOT_HANDLE;
     }
   }
-  return result;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollBegin(
     const WebGestureEvent& gesture_event) {
   if (gesture_scroll_on_impl_thread_)
     CancelCurrentFling();
 
 #ifndef NDEBUG
   DCHECK(!expect_scroll_update_end_);
   expect_scroll_update_end_ = true;
@@ skipping 648 matching lines @@
     input_handler_->SetNeedsAnimateInput();
 }
 
 bool InputHandlerProxy::TouchpadFlingScroll(
     const WebFloatSize& increment) {
   InputHandlerProxy::EventDisposition disposition;
   cc::EventListenerProperties properties =
       input_handler_->GetEventListenerProperties(
           cc::EventListenerClass::kMouseWheel);
   switch (properties) {
-    case cc::EventListenerProperties::kPassive:
-      disposition = DID_HANDLE_NON_BLOCKING;
-      break;
     case cc::EventListenerProperties::kBlocking:
       disposition = DID_NOT_HANDLE;
       break;
+    case cc::EventListenerProperties::kPassive:
     case cc::EventListenerProperties::kNone: {
       WebMouseWheelEvent synthetic_wheel;
       synthetic_wheel.type = WebInputEvent::MouseWheel;
       synthetic_wheel.timeStampSeconds = InSecondsF(base::TimeTicks::Now());
       synthetic_wheel.deltaX = increment.width;
       synthetic_wheel.deltaY = increment.height;
       synthetic_wheel.hasPreciseScrollingDeltas = true;
       synthetic_wheel.x = fling_parameters_.point.x;
       synthetic_wheel.y = fling_parameters_.point.y;
       synthetic_wheel.globalX = fling_parameters_.globalPoint.x;
       synthetic_wheel.globalY = fling_parameters_.globalPoint.y;
       synthetic_wheel.modifiers = fling_parameters_.modifiers;
 
-      disposition = ScrollByMouseWheel(synthetic_wheel);
+      disposition = ScrollByMouseWheel(synthetic_wheel, properties);
+
+      // Send the event over to the main thread.
+      if (disposition == DID_HANDLE_NON_BLOCKING) {
+        client_->DispatchNonBlockingEventToMainThread(
+            ui::WebInputEventTraits::Clone(synthetic_wheel), ui::LatencyInfo());
+      }
       break;
     }
     default:
       NOTREACHED();
       return false;
   }
 
   switch (disposition) {
     case DID_HANDLE:
+    case DID_HANDLE_NON_BLOCKING:
       return true;
     case DROP_EVENT:
       break;
-    case DID_HANDLE_NON_BLOCKING:
-    // TODO(dtapuska): Process the fling on the compositor thread
-    // but post the events to the main thread; for now just pass it to the
-    // main thread.
     case DID_NOT_HANDLE:
       TRACE_EVENT_INSTANT0("input",
                            "InputHandlerProxy::scrollBy::AbortFling",
                            TRACE_EVENT_SCOPE_THREAD);
       // If we got a DID_NOT_HANDLE, that means we need to deliver wheels on the
       // main thread. In this case we need to schedule a commit and transfer the
       // fling curve over to the main thread and run the rest of the wheels from
       // there. This can happen when flinging a page that contains a scrollable
       // subarea that we can't scroll on the thread if the fling starts outside
       // the subarea but then is flung "under" the pointer.
@@ skipping 83 matching lines @@
   // 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,
                  scroll_result));
 }
 
 }  // namespace ui