Plumb firing passive event listeners.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 553 matching lines @@
   if ((scrolling_layer_impl == InnerViewportScrollLayer() &&
        test_layer_impl == OuterViewportScrollLayer()) ||
       (scrolling_layer_impl == OuterViewportScrollLayer() &&
        test_layer_impl == InnerViewportScrollLayer())) {
     return true;
   }
 
   return false;
 }
 
-bool LayerTreeHostImpl::HaveWheelEventHandlersAt(
-    const gfx::Point& viewport_point) {
-  gfx::PointF device_viewport_point = gfx::ScalePoint(
-      gfx::PointF(viewport_point), active_tree_->device_scale_factor());
-
-  LayerImpl* layer_impl =
-      active_tree_->FindLayerWithWheelHandlerThatIsHitByPoint(
-          device_viewport_point);
-
-  return layer_impl != NULL;
-}
-
 static LayerImpl* NextLayerInScrollOrder(LayerImpl* layer) {
   if (layer->scroll_parent())
     return layer->scroll_parent();
 
   return layer->parent();
 }
 
 static ScrollBlocksOn EffectiveScrollBlocksOn(LayerImpl* layer) {
   ScrollBlocksOn blocks = SCROLL_BLOCKS_ON_NONE;
   for (; layer; layer = NextLayerInScrollOrder(layer)) {
@@ skipping 17 matching lines @@
   if (!(blocking & SCROLL_BLOCKS_ON_START_TOUCH))
     return false;
 
   // Now determine if there are actually any handlers at that point.
   // TODO(rbyers): Consider also honoring touch-action (crbug.com/347272).
   layer_impl = active_tree_->FindLayerThatIsHitByPointInTouchHandlerRegion(
       device_viewport_point);
   return layer_impl != NULL;
 }
 
+uint32_t LayerTreeHostImpl::EffectiveWheelEventListenerPropertiesAt(
+    const gfx::Point& viewport_point) {
+  gfx::PointF device_viewport_point = gfx::ScalePoint(
+      gfx::PointF(viewport_point), active_tree_->device_scale_factor());
+
+  LayerImpl* layer_impl =
+      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
+
+  uint32_t result = EventListenerProperties::kNone;
+  for (; layer_impl; layer_impl = NextLayerInScrollOrder(layer_impl)) {
+    result |= layer_impl->wheel_event_properties();
+  }
+
+  return result;
+}
+
+uint32_t LayerTreeHostImpl::EffectiveTouchEventListenerPropertiesAt(
+    const gfx::Point& viewport_point) {
+  gfx::PointF device_viewport_point = gfx::ScalePoint(
+      gfx::PointF(viewport_point), active_tree_->device_scale_factor());
+
+  LayerImpl* layer_impl =
+      active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
+
+  uint32_t result = EventListenerProperties::kNone;

[tdresser, 2016/01/26 16:34:37]

Where is EventListenerProperties defined?
Could we just use separate properties for wheel and touch, to avoid the need for
two methods here?

[dtapuska, 2016/01/26 16:53:15]

Defined in dependent patch:
https://codereview.chromium.org/1577263004/patch/60001/70004

I think enuming it based on the types would eventually get messy as ideally need
to do it for keyboard as well. But I do agree this is duplicated code.. 

[tdresser, 2016/01/26 18:45:42]

What about something like:
struct EventListenerProperties {
  enum : uint32_t { kNone = 0 };
  enum : uint32_t { kBlocking = 1 << 0 };
  enum : uint32_t { kPassive = 1 << 1 };
  enum : uint32_t { kTypeTouch = 1 << 2 };
  enum : uint32_t { kTypeWheel = 1 << 3 };
  enum : uint32_t { kTypeKeyboard = 1 << 4 };
  enum : uint32_t { kMax = (1 << 5) - 1 };
};

[dtapuska, 2016/01/26 18:56:49]

I think that limits the verbosity of the code. For example describing a passive
wheel listener and a blocking touch listener is not possible.

I do think we could get away with enumerating the types of input. And change
these to something like EffectiveEventListenersPropertiesAt(InputType,
const::gfx::Point&);

where InputType is 

enum class InputType {
Touch,
MouseWheel,
Keyboard
};

[tdresser, 2016/01/26 18:58:19]

Good point.
SGTM

+  for (; layer_impl; layer_impl = NextLayerInScrollOrder(layer_impl)) {
+    result |= layer_impl->touch_event_properties();
+  }
+
+  return result;
+}
+
 scoped_ptr<SwapPromiseMonitor>
 LayerTreeHostImpl::CreateLatencyInfoSwapPromiseMonitor(
     ui::LatencyInfo* latency) {
   return make_scoped_ptr(
       new LatencyInfoSwapPromiseMonitor(latency, NULL, this));
 }
 
 ScrollElasticityHelper* LayerTreeHostImpl::CreateScrollElasticityHelper() {
   DCHECK(!scroll_elasticity_helper_);
   if (settings_.enable_elastic_overscroll) {
@@ skipping 3269 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc