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 1189 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);
+
+      // Send the event over to the main thread.
+      if (disposition == DID_HANDLE_NON_BLOCKING) {
+        client_->DispatchNonBlockingEventToMainThread(
+            ui::WebInputEventTraits::Clone(synthetic_wheel));
+      }
       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