Plumb firing passive event listeners.

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 203 matching lines @@
 #ifndef NDEBUG
       expect_scroll_update_end_(false),
 #endif
       gesture_scroll_on_impl_thread_(false),
       gesture_pinch_on_impl_thread_(false),
       fling_may_be_active_on_main_thread_(false),
       disallow_horizontal_fling_scroll_(false),
       disallow_vertical_fling_scroll_(false),
       has_fling_animation_started_(false),
       smooth_scroll_enabled_(false),
-      uma_latency_reporting_enabled_(base::TimeTicks::IsHighResolution()) {
+      uma_latency_reporting_enabled_(base::TimeTicks::IsHighResolution()),
+      scroll_on_mouse_wheel_(false) {
   DCHECK(client);
   input_handler_->BindToClient(this);
   cc::ScrollElasticityHelper* scroll_elasticity_helper =
       input_handler_->CreateScrollElasticityHelper();
   if (scroll_elasticity_helper) {
     scroll_elasticity_controller_.reset(
         new InputScrollElasticityController(scroll_elasticity_helper));
   }
 }
 
@@ skipping 46 matching lines @@
           static_cast<const WebGestureEvent&>(event));
 
     case WebInputEvent::GestureScrollEnd:
       return HandleGestureScrollEnd(static_cast<const WebGestureEvent&>(event));
 
     case WebInputEvent::GesturePinchBegin: {
       DCHECK(!gesture_pinch_on_impl_thread_);
       const WebGestureEvent& gesture_event =
           static_cast<const WebGestureEvent&>(event);
       if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad &&
-          input_handler_->HaveWheelEventHandlersAt(
-              gfx::Point(gesture_event.x, gesture_event.y))) {
+          input_handler_->EffectiveWheelEventListenerPropertiesAt(
+              gfx::Point(gesture_event.x, gesture_event.y)) !=
+              cc::EventListenerProperties::kNone) {
         return DID_NOT_HANDLE;
       } else {
         input_handler_->PinchGestureBegin();
         gesture_pinch_on_impl_thread_ = true;
         return DID_HANDLE;
       }
     }
 
     case WebInputEvent::GesturePinchEnd:
       if (gesture_pinch_on_impl_thread_) {
@@ skipping 26 matching lines @@
     case WebInputEvent::GestureFlingCancel:
       if (CancelCurrentFling())
         return DID_HANDLE;
       else if (!fling_may_be_active_on_main_thread_)
         return DROP_EVENT;
       return DID_NOT_HANDLE;
 
     case WebInputEvent::TouchStart:
       return HandleTouchStart(static_cast<const WebTouchEvent&>(event));
 
+    case WebInputEvent::TouchMove:
+      return HandleTouchMove(static_cast<const WebTouchEvent&>(event));
+
     case WebInputEvent::MouseMove: {
       const WebMouseEvent& mouse_event =
           static_cast<const WebMouseEvent&>(event);
       // TODO(tony): Ignore when mouse buttons are down?
       // TODO(davemoore): This should never happen, but bug #326635 showed some
       // surprising crashes.
       CHECK(input_handler_);
       input_handler_->MouseMoveAt(gfx::Point(mouse_event.x, mouse_event.y));
       return DID_NOT_HANDLE;
     }
@@ skipping 63 matching lines @@
 #if defined(OS_MACOSX)
   // Mac does not smooth scroll wheel events (crbug.com/574283).
   return false;
 #else
   return smooth_scroll_enabled_ && !event.hasPreciseScrollingDeltas;
 #endif
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleMouseWheel(
     const WebMouseWheelEvent& wheel_event) {
+  if (!scroll_on_mouse_wheel_) {
+    if (input_handler_->EffectiveWheelEventListenerPropertiesAt(
+            gfx::Point(wheel_event.x, wheel_event.y)) ==
+        cc::EventListenerProperties::kPassive) {
+      return NON_BLOCKING;
+    }
+    return DID_NOT_HANDLE;
+  }
+
   InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
   cc::InputHandlerScrollResult scroll_result;
 
   // 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
@@ skipping 281 matching lines @@
         return DID_NOT_HANDLE;
       }
       return DROP_EVENT;
     }
   }
   return DID_NOT_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchStart(
     const blink::WebTouchEvent& touch_event) {
-  for (size_t i = 0; i < touch_event.touchesLength; ++i) {
+  uint32_t properties = cc::EventListenerProperties::kNone;
+  for (size_t i = 0; i < touch_event.touchesLength &&
+                     properties != cc::EventListenerProperties::kMax;
+       ++i) {
     if (touch_event.touches[i].state != WebTouchPoint::StatePressed)
       continue;
-    if (input_handler_->DoTouchEventsBlockScrollAt(
-            gfx::Point(touch_event.touches[i].position.x,
-                       touch_event.touches[i].position.y))) {
-      // TODO(rbyers): We should consider still sending the touch events to
-      // main asynchronously (crbug.com/455539).
-      return DID_NOT_HANDLE;
-    }
+
+    properties |= input_handler_->EffectiveTouchEventListenerPropertiesAt(
+        gfx::Point(touch_event.touches[i].position.x,
+                   touch_event.touches[i].position.y));
   }
-  return DROP_EVENT;
+
+  if (properties == cc::EventListenerProperties::kPassive) {
+    return NON_BLOCKING;
+  }
+  return DID_NOT_HANDLE;
+}
+
+InputHandlerProxy::EventDisposition InputHandlerProxy::HandleTouchMove(
+    const blink::WebTouchEvent& touch_event) {
+  uint32_t properties = cc::EventListenerProperties::kNone;
+  for (size_t i = 0; i < touch_event.touchesLength &&
+                     properties != cc::EventListenerProperties::kMax;
+       ++i) {
+    properties |= input_handler_->EffectiveTouchEventListenerPropertiesAt(
+        gfx::Point(touch_event.touches[i].position.x,
+                   touch_event.touches[i].position.y));
+  }
+
+  if (properties == cc::EventListenerProperties::kPassive) {
+    return NON_BLOCKING;
+  }
+  return DID_NOT_HANDLE;
 }
 
 bool InputHandlerProxy::FilterInputEventForFlingBoosting(
     const WebInputEvent& event) {
   if (!WebInputEvent::isGestureEventType(event.type))
     return false;
 
   if (!fling_curve_) {
     DCHECK(!deferred_fling_cancel_time_seconds_);
     return false;
@@ skipping 341 matching lines @@
   synthetic_wheel.globalY = fling_parameters_.globalPoint.y;
   synthetic_wheel.modifiers = fling_parameters_.modifiers;
 
   InputHandlerProxy::EventDisposition disposition =
       HandleInputEvent(synthetic_wheel);
   switch (disposition) {
     case DID_HANDLE:
       return true;
     case DROP_EVENT:
       break;
+    case 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 64 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