Communicate whether passive event listeners exist to cc.

cc/trees/layer_tree_host_impl_unittest.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 <algorithm>
 #include <cmath>
@@ skipping 668 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   // With registered event handlers, wheel scrolls don't necessarily
   // have to go to the main thread.
-  root->SetHaveWheelEventHandlers(true);
+  root->SetWheelEventProperties(EventListenerProperties::BLOCKING);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
   host_impl_->ScrollEnd();
 
   // But typically the scroll-blocks-on mode will require them to.
   root->SetScrollBlocksOn(SCROLL_BLOCKS_ON_WHEEL_EVENT |
                           SCROLL_BLOCKS_ON_START_TOUCH);
   EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 
   // But gesture scrolls can still be handled.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   host_impl_->ScrollEnd();
 
   // And if the handlers go away, wheel scrolls can again be processed
   // on impl (despite the scroll-blocks-on mode).
-  root->SetHaveWheelEventHandlers(false);
+  root->SetWheelEventProperties(EventListenerProperties::NONE);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
   host_impl_->ScrollEnd();
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlocksOnTouchEventHandlers) {
   LayerImpl* scroll = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
   LayerImpl* root = host_impl_->active_tree()->root_layer();
@@ skipping 79 matching lines @@
 
   // Create two child scrollable layers
   LayerImpl* child1 = 0;
   {
     scoped_ptr<LayerImpl> scrollable_child_clip_1 =
         LayerImpl::Create(host_impl_->active_tree(), 6);
     scoped_ptr<LayerImpl> scrollable_child_1 = CreateScrollableLayer(
         7, gfx::Size(10, 10), scrollable_child_clip_1.get());
     child1 = scrollable_child_1.get();
     scrollable_child_1->SetPosition(gfx::PointF(5.f, 5.f));
-    scrollable_child_1->SetHaveWheelEventHandlers(true);
+    scrollable_child_1->SetWheelEventProperties(
+        EventListenerProperties::BLOCKING);
     scrollable_child_1->SetHaveScrollEventHandlers(true);
     scrollable_child_clip_1->AddChild(std::move(scrollable_child_1));
     root_child->AddChild(std::move(scrollable_child_clip_1));
     RebuildPropertyTrees();
   }
 
   LayerImpl* child2 = 0;
   {
     scoped_ptr<LayerImpl> scrollable_child_clip_2 =
         LayerImpl::Create(host_impl_->active_tree(), 8);
     scoped_ptr<LayerImpl> scrollable_child_2 = CreateScrollableLayer(
         9, gfx::Size(10, 10), scrollable_child_clip_2.get());
     child2 = scrollable_child_2.get();
     scrollable_child_2->SetPosition(gfx::PointF(5.f, 20.f));
-    scrollable_child_2->SetHaveWheelEventHandlers(true);
+    scrollable_child_2->SetWheelEventProperties(
+        EventListenerProperties::BLOCKING);
     scrollable_child_2->SetHaveScrollEventHandlers(true);
     scrollable_child_clip_2->AddChild(std::move(scrollable_child_2));
     root_child->AddChild(std::move(scrollable_child_clip_2));
     RebuildPropertyTrees();
   }
 
   // Scroll-blocks-on on a layer affects scrolls that hit that layer.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(10, 10), InputHandler::GESTURE));
   host_impl_->ScrollEnd();
@@ skipping 8642 matching lines @@
     // There should not be any jitter measured till we hit the fixed point hits
     // threshold.
     float expected_jitter =
         (i == pending_tree->kFixedPointHitsThreshold) ? 500 : 0;
     EXPECT_EQ(jitter, expected_jitter);
   }
 }
 
 }  // namespace
 }  // namespace cc