Communicate whether passive event listeners exist to cc.

cc does nothing with these new fields being set other than plumbing them
through the pipeline to be later queried on the layer_impl.

Add an additional field whether touch event listeners exist on the layer
(which unfortunately is effectively implement as an entire document field
in the blink EventListenerRegistry; this can be improved). There still
exists TouchRegionRects that indicate the areas of blocking event
listeners; but whether a passive event listener exists will be indicated
in this field. It is intended that this model will be replicated
with property trees when it is ready.

BUG=489802
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1577263004

Cr-Commit-Position: refs/heads/master@{#373915}

16 files changed, 121 insertions, 35 deletions

diff --git a/cc/debug/debug_rect_history.cc b/cc/debug/debug_rect_history.cc
index 59ca9de..87d83b8 100644
--- a/cc/debug/debug_rect_history.cc
+++ b/cc/debug/debug_rect_history.cc
@@ -181,8 +181,14 @@ void DebugRectHistory::SaveWheelEventHandlerRects(LayerImpl* layer) {
 }
 
 void DebugRectHistory::SaveWheelEventHandlerRectsCallback(LayerImpl* layer) {
-  if (!layer->layer_tree_impl()->have_wheel_event_handlers())
+  EventListenerProperties event_properties =
+      layer->layer_tree_impl()->event_listener_properties(
+          EventListenerClass::kMouseWheel);
+  if (event_properties == EventListenerProperties::kNone ||
+      (layer->layer_tree_impl()->settings().use_mouse_wheel_gestures &&
+       event_properties == EventListenerProperties::kPassive)) {
     return;
+  }
 
   debug_rects_.push_back(
       DebugRect(WHEEL_EVENT_HANDLER_RECT_TYPE,
diff --git a/cc/input/event_listener_properties.h b/cc/input/event_listener_properties.h
new file mode 100644
index 0000000..2755c6e
--- /dev/null
+++ b/cc/input/event_listener_properties.h
@@ -0,0 +1,16 @@
+// Copyright 2016 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.
+
+#ifndef CC_INPUT_EVENT_LISTENER_PROPERTIES_H_
+#define CC_INPUT_EVENT_LISTENER_PROPERTIES_H_
+
+namespace cc {
+
+enum class EventListenerClass { kTouch, kMouseWheel, kNumClasses };
+
+enum class EventListenerProperties { kNone, kPassive, kBlocking, kMax };
+
+}  // namespace cc
+
+#endif  // CC_INPUT_EVENT_LISTENER_PROPERTIES_H_
diff --git a/cc/input/input_handler.h b/cc/input/input_handler.h
index 449c471..9a39562 100644
--- a/cc/input/input_handler.h
+++ b/cc/input/input_handler.h
@@ -9,6 +9,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "cc/base/cc_export.h"
+#include "cc/input/event_listener_properties.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/input/scroll_state.h"
 #include "cc/input/scrollbar.h"
@@ -170,7 +171,8 @@ class CC_EXPORT InputHandler {
   virtual bool IsCurrentlyScrollingLayerAt(const gfx::Point& viewport_point,
                                            ScrollInputType type) const = 0;
 
-  virtual bool HaveWheelEventHandlers() const = 0;
+  virtual EventListenerProperties GetEventListenerProperties(
+      EventListenerClass event_class) const = 0;
 
   // Whether the page should be given the opportunity to suppress scrolling by
   // consuming touch events that started at |viewport_point|.
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 173237a..56b79e8 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -556,13 +556,19 @@ InputHandler::ScrollStatus LayerImpl::TryScroll(
     }
   }
 
-  if ((type == InputHandler::WHEEL || type == InputHandler::ANIMATED_WHEEL) &&
-      layer_tree_impl_->have_wheel_event_handlers()) {
-    TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
-    scroll_status.thread = InputHandler::SCROLL_ON_MAIN_THREAD;
-    scroll_status.main_thread_scrolling_reasons =
-        MainThreadScrollingReason::kEventHandlers;
-    return scroll_status;
+  if (type == InputHandler::WHEEL || type == InputHandler::ANIMATED_WHEEL) {
+    EventListenerProperties event_properties =
+        layer_tree_impl_->event_listener_properties(
+            EventListenerClass::kMouseWheel);
+    if (event_properties == EventListenerProperties::kBlocking ||
+        (!layer_tree_impl_->settings().use_mouse_wheel_gestures &&
+         event_properties == EventListenerProperties::kPassive)) {
+      TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
+      scroll_status.thread = InputHandler::SCROLL_ON_MAIN_THREAD;
+      scroll_status.main_thread_scrolling_reasons =
+          MainThreadScrollingReason::kEventHandlers;
+      return scroll_status;
+    }
   }
 
   if (!scrollable()) {
diff --git a/cc/proto/layer_tree_host.proto b/cc/proto/layer_tree_host.proto
index 9a6ac11..d1d78e7 100644
--- a/cc/proto/layer_tree_host.proto
+++ b/cc/proto/layer_tree_host.proto
@@ -53,6 +53,7 @@ message LayerTreeHost {
   optional PropertyTrees property_trees = 31;
   optional uint32 surface_id_namespace = 32;
   optional uint32 next_surface_sequence = 33;
-  optional bool have_wheel_event_handlers = 34;
+  optional uint32 wheel_event_listener_properties = 34;
   optional bool have_scroll_event_handlers = 35;
+  optional uint32 touch_event_listener_properties = 36;
 }
diff --git a/cc/proto/layer_tree_settings.proto b/cc/proto/layer_tree_settings.proto
index 1c0bb85..844d75b1 100644
--- a/cc/proto/layer_tree_settings.proto
+++ b/cc/proto/layer_tree_settings.proto
@@ -70,4 +70,5 @@ message LayerTreeSettings {
   optional int32 max_staging_buffer_usage_in_bytes = 47;
   optional ManagedMemoryPolicy memory_policy = 48;
   optional LayerTreeDebugState initial_debug_state = 49;
+  optional bool use_mouse_wheel_gestures = 50;
 }
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 2de6b3b..c2e08dd 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -184,7 +184,7 @@ LayerTreeHost::LayerTreeHost(InitParams* params, CompositorMode mode)
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
       have_scroll_event_handlers_(false),
-      have_wheel_event_handlers_(false),
+      event_listener_properties_(),
       did_complete_scale_animation_(false),
       in_paint_layer_contents_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
@@ -401,7 +401,12 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
   sync_tree->set_have_scroll_event_handlers(have_scroll_event_handlers_);
-  sync_tree->set_have_wheel_event_handlers(have_wheel_event_handlers_);
+  sync_tree->set_event_listener_properties(
+      EventListenerClass::kTouch,
+      event_listener_properties(EventListenerClass::kTouch));
+  sync_tree->set_event_listener_properties(
+      EventListenerClass::kMouseWheel,
+      event_listener_properties(EventListenerClass::kMouseWheel));
 
   if (page_scale_layer_.get() && inner_viewport_scroll_layer_.get()) {
     sync_tree->SetViewportLayersFromIds(
@@ -1124,11 +1129,14 @@ void LayerTreeHost::SetHaveScrollEventHandlers(bool have_event_handlers) {
   SetNeedsCommit();
 }
 
-void LayerTreeHost::SetHaveWheelEventHandlers(bool have_event_handlers) {
-  if (have_wheel_event_handlers_ == have_event_handlers)
+void LayerTreeHost::SetEventListenerProperties(
+    EventListenerClass event_class,
+    EventListenerProperties properties) {
+  const size_t index = static_cast<size_t>(event_class);
+  if (event_listener_properties_[index] == properties)
     return;
 
-  have_wheel_event_handlers_ = have_event_handlers;
+  event_listener_properties_[index] = properties;
   SetNeedsCommit();
 }
 
@@ -1458,7 +1466,10 @@ void LayerTreeHost::ToProtobufForCommit(proto::LayerTreeHost* proto) const {
   proto->set_background_color(background_color_);
   proto->set_has_transparent_background(has_transparent_background_);
   proto->set_have_scroll_event_handlers(have_scroll_event_handlers_);
-  proto->set_have_wheel_event_handlers(have_wheel_event_handlers_);
+  proto->set_wheel_event_listener_properties(static_cast<uint32_t>(
+      event_listener_properties(EventListenerClass::kMouseWheel)));
+  proto->set_touch_event_listener_properties(static_cast<uint32_t>(
+      event_listener_properties(EventListenerClass::kTouch)));
   proto->set_in_paint_layer_contents(in_paint_layer_contents_);
   proto->set_id(id_);
   proto->set_next_commit_forces_redraw(next_commit_forces_redraw_);
@@ -1525,7 +1536,13 @@ void LayerTreeHost::FromProtobufForCommit(const proto::LayerTreeHost& proto) {
   background_color_ = proto.background_color();
   has_transparent_background_ = proto.has_transparent_background();
   have_scroll_event_handlers_ = proto.have_scroll_event_handlers();
-  have_wheel_event_handlers_ = proto.have_wheel_event_handlers();
+  event_listener_properties_[static_cast<size_t>(
+      EventListenerClass::kMouseWheel)] =
+      static_cast<EventListenerProperties>(
+          proto.wheel_event_listener_properties());
+  event_listener_properties_[static_cast<size_t>(EventListenerClass::kTouch)] =
+      static_cast<EventListenerProperties>(
+          proto.touch_event_listener_properties());
   in_paint_layer_contents_ = proto.in_paint_layer_contents();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index 9118e12..ffc028e 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -25,6 +25,7 @@
 #include "cc/debug/frame_timing_tracker.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/debug/micro_benchmark_controller.h"
+#include "cc/input/event_listener_properties.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/scrollbar.h"
@@ -229,8 +230,12 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient {
   }
   void SetHaveScrollEventHandlers(bool have_event_handlers);
 
-  bool have_wheel_event_handlers() const { return have_wheel_event_handlers_; }
-  void SetHaveWheelEventHandlers(bool have_event_handlers);
+  void SetEventListenerProperties(EventListenerClass event_class,
+                                  EventListenerProperties event_properties);
+  EventListenerProperties event_listener_properties(
+      EventListenerClass event_class) const {
+    return event_listener_properties_[static_cast<size_t>(event_class)];
+  }
 
   const LayerTreeSettings& settings() const { return settings_; }
 
@@ -538,7 +543,8 @@ class CC_EXPORT LayerTreeHost : public MutatorHostClient {
   bool has_transparent_background_;
 
   bool have_scroll_event_handlers_;
-  bool have_wheel_event_handlers_;
+  EventListenerProperties event_listener_properties_[static_cast<size_t>(
+      EventListenerClass::kNumClasses)];
 
   scoped_ptr<AnimationRegistrar> animation_registrar_;
   scoped_ptr<AnimationHost> animation_host_;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index f2e31d6..7eaa142 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -572,8 +572,9 @@ bool LayerTreeHostImpl::IsCurrentlyScrollingLayerAt(
   return false;
 }
 
-bool LayerTreeHostImpl::HaveWheelEventHandlers() const {
-  return active_tree_->have_wheel_event_handlers();
+EventListenerProperties LayerTreeHostImpl::GetEventListenerProperties(
+    EventListenerClass event_class) const {
+  return active_tree_->event_listener_properties(event_class);
 }
 
 bool LayerTreeHostImpl::DoTouchEventsBlockScrollAt(
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 343cc77..6962fad 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -192,7 +192,8 @@ class CC_EXPORT LayerTreeHostImpl
   bool IsCurrentlyScrollingLayerAt(
       const gfx::Point& viewport_point,
       InputHandler::ScrollInputType type) const override;
-  bool HaveWheelEventHandlers() const override;
+  EventListenerProperties GetEventListenerProperties(
+      EventListenerClass event_class) const override;
   bool DoTouchEventsBlockScrollAt(const gfx::Point& viewport_port) override;
   scoped_ptr<SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
       ui::LatencyInfo* latency) override;
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 9ea8484..fe913c3 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -717,7 +717,8 @@ TEST_F(LayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) {
 
   // With registered event handlers, wheel scrolls don't necessarily
   // have to go to the main thread.
-  host_impl_->active_tree()->set_have_wheel_event_handlers(true);
+  host_impl_->active_tree()->set_event_listener_properties(
+      EventListenerClass::kMouseWheel, EventListenerProperties::kBlocking);
   InputHandler::ScrollStatus status =
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                    InputHandler::WHEEL);
@@ -734,8 +735,9 @@ TEST_F(LayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) {
   host_impl_->ScrollEnd(EndState().get());
 
   // And if the handlers go away, wheel scrolls can again be processed
-  // on impl (despite the scroll-blocks-on mode).
-  host_impl_->active_tree()->set_have_wheel_event_handlers(false);
+  // on impl.
+  host_impl_->active_tree()->set_event_listener_properties(
+      EventListenerClass::kMouseWheel, EventListenerProperties::kNone);
   status = host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                    InputHandler::WHEEL);
   EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD, status.thread);
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 560df10..89c47e1 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -1333,7 +1333,10 @@ class LayerTreeHostTestCommit : public LayerTreeHostTest {
   void BeginTest() override {
     layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
     layer_tree_host()->set_background_color(SK_ColorGRAY);
-    layer_tree_host()->SetHaveWheelEventHandlers(true);
+    layer_tree_host()->SetEventListenerProperties(
+        EventListenerClass::kMouseWheel, EventListenerProperties::kPassive);
+    layer_tree_host()->SetEventListenerProperties(
+        EventListenerClass::kTouch, EventListenerProperties::kBlocking);
     layer_tree_host()->SetHaveScrollEventHandlers(true);
 
     PostSetNeedsCommitToMainThread();
@@ -1342,7 +1345,12 @@ class LayerTreeHostTestCommit : public LayerTreeHostTest {
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     EXPECT_EQ(gfx::Size(20, 20), impl->DrawViewportSize());
     EXPECT_EQ(SK_ColorGRAY, impl->active_tree()->background_color());
-    EXPECT_TRUE(impl->active_tree()->have_wheel_event_handlers());
+    EXPECT_EQ(EventListenerProperties::kPassive,
+              impl->active_tree()->event_listener_properties(
+                  EventListenerClass::kMouseWheel));
+    EXPECT_EQ(EventListenerProperties::kBlocking,
+              impl->active_tree()->event_listener_properties(
+                  EventListenerClass::kTouch));
     EXPECT_TRUE(impl->active_tree()->have_scroll_event_handlers());
 
     EndTest();
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 156996d..46561da 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -77,7 +77,7 @@ LayerTreeImpl::LayerTreeImpl(
       has_ever_been_drawn_(false),
       render_surface_layer_list_id_(0),
       have_scroll_event_handlers_(false),
-      have_wheel_event_handlers_(false),
+      event_listener_properties_(),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0),
       top_controls_shown_ratio_(top_controls_shown_ratio) {}
@@ -348,7 +348,12 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   target_tree->set_background_color(background_color());
   target_tree->set_has_transparent_background(has_transparent_background());
   target_tree->set_have_scroll_event_handlers(have_scroll_event_handlers());
-  target_tree->set_have_wheel_event_handlers(have_wheel_event_handlers());
+  target_tree->set_event_listener_properties(
+      EventListenerClass::kTouch,
+      event_listener_properties(EventListenerClass::kTouch));
+  target_tree->set_event_listener_properties(
+      EventListenerClass::kMouseWheel,
+      event_listener_properties(EventListenerClass::kMouseWheel));
 
   if (ViewportSizeInvalid())
     target_tree->SetViewportSizeInvalid();
@@ -1690,7 +1695,9 @@ struct HitTestVisibleScrollableOrTouchableFunctor {
     return layer->IsDrawnRenderSurfaceLayerListMember() ||
            ScrollsAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty() ||
-           layer->layer_tree_impl()->have_wheel_event_handlers();
+           layer->layer_tree_impl()->event_listener_properties(
+               EventListenerClass::kMouseWheel) !=
+               EventListenerProperties::kNone;
   }
 };
 
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 7f4c89c..5614035 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -14,6 +14,7 @@
 #include "base/macros.h"
 #include "base/values.h"
 #include "cc/base/synced_property.h"
+#include "cc/input/event_listener_properties.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/begin_frame_args.h"
@@ -443,9 +444,14 @@ class CC_EXPORT LayerTreeImpl {
     have_scroll_event_handlers_ = have_event_handlers;
   }
 
-  bool have_wheel_event_handlers() const { return have_wheel_event_handlers_; }
-  void set_have_wheel_event_handlers(bool have_event_handlers) {
-    have_wheel_event_handlers_ = have_event_handlers;
+  EventListenerProperties event_listener_properties(
+      EventListenerClass event_class) const {
+    return event_listener_properties_[static_cast<size_t>(event_class)];
+  }
+  void set_event_listener_properties(EventListenerClass event_class,
+                                     EventListenerProperties event_properties) {
+    event_listener_properties_[static_cast<size_t>(event_class)] =
+        event_properties;
   }
 
  protected:
@@ -536,7 +542,8 @@ class CC_EXPORT LayerTreeImpl {
   int render_surface_layer_list_id_;
 
   bool have_scroll_event_handlers_;
-  bool have_wheel_event_handlers_;
+  EventListenerProperties event_listener_properties_[static_cast<size_t>(
+      EventListenerClass::kNumClasses)];
 
   // Whether or not Blink's viewport size was shrunk by the height of the top
   // controls at the time of the last layout.
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index ee0c957..da6c031 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -103,6 +103,7 @@ LayerTreeSettings::LayerTreeSettings()
       image_decode_tasks_enabled(false),
       use_compositor_animation_timelines(true),
       wait_for_beginframe_interval(true),
+      use_mouse_wheel_gestures(false),
       max_staging_buffer_usage_in_bytes(32 * 1024 * 1024),
       memory_policy_(64 * 1024 * 1024,
                      gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
@@ -171,6 +172,7 @@ bool LayerTreeSettings::operator==(const LayerTreeSettings& other) const {
          use_compositor_animation_timelines ==
              other.use_compositor_animation_timelines &&
          wait_for_beginframe_interval == other.wait_for_beginframe_interval &&
+         use_mouse_wheel_gestures == other.use_mouse_wheel_gestures &&
          max_staging_buffer_usage_in_bytes ==
              other.max_staging_buffer_usage_in_bytes &&
          memory_policy_ == other.memory_policy_ &&
@@ -235,6 +237,7 @@ void LayerTreeSettings::ToProtobuf(proto::LayerTreeSettings* proto) const {
   proto->set_use_compositor_animation_timelines(
       use_compositor_animation_timelines);
   proto->set_wait_for_beginframe_interval(wait_for_beginframe_interval);
+  proto->set_use_mouse_wheel_gestures(use_mouse_wheel_gestures);
   proto->set_max_staging_buffer_usage_in_bytes(
       max_staging_buffer_usage_in_bytes);
   memory_policy_.ToProtobuf(proto->mutable_memory_policy());
@@ -303,6 +306,7 @@ void LayerTreeSettings::FromProtobuf(const proto::LayerTreeSettings& proto) {
   use_compositor_animation_timelines =
       proto.use_compositor_animation_timelines();
   wait_for_beginframe_interval = proto.wait_for_beginframe_interval();
+  use_mouse_wheel_gestures = proto.use_mouse_wheel_gestures();
   max_staging_buffer_usage_in_bytes = proto.max_staging_buffer_usage_in_bytes();
   memory_policy_.FromProtobuf(proto.memory_policy());
   initial_debug_state.FromProtobuf(proto.initial_debug_state());
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index b5e983b..ff00f5d 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -88,6 +88,7 @@ class CC_EXPORT LayerTreeSettings {
   bool image_decode_tasks_enabled;
   bool use_compositor_animation_timelines;
   bool wait_for_beginframe_interval;
+  bool use_mouse_wheel_gestures;
   int max_staging_buffer_usage_in_bytes;
   ManagedMemoryPolicy memory_policy_;