Plumb firing passive event listeners.

ui/events/blink/input_handler_proxy_unittest.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 "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/trees/swap_promise_monitor.h"
@@ skipping 113 matching lines @@
   }
 
   void BindToClient(cc::InputHandlerClient* client) override {}
 
   void MouseMoveAt(const gfx::Point& mouse_position) override {}
 
   MOCK_CONST_METHOD2(IsCurrentlyScrollingLayerAt,
                      bool(const gfx::Point& point,
                           cc::InputHandler::ScrollInputType type));
 
-  MOCK_METHOD1(HaveWheelEventHandlersAt, bool(const gfx::Point& point));
   MOCK_METHOD1(DoTouchEventsBlockScrollAt, bool(const gfx::Point& point));
 
+  MOCK_METHOD1(EffectiveWheelEventListenerPropertiesAt,
+               uint32_t(const gfx::Point& point));
+  MOCK_METHOD1(EffectiveTouchEventListenerPropertiesAt,
+               uint32_t(const gfx::Point& point));
+
   MOCK_METHOD0(RequestUpdateForSynchronousInputHandler, void());
   MOCK_METHOD1(SetSynchronousInputHandlerRootScrollOffset,
                void(const gfx::ScrollOffset& root_offset));
 
   bool IsCurrentlyScrollingInnerViewport() const override {
     return is_scrolling_root_;
   }
   void set_is_scrolling_root(bool is) { is_scrolling_root_ = is; }
 
  private:
@@ skipping 471 matching lines @@
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GesturePinch) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchBegin;
-  EXPECT_CALL(mock_input_handler_, HaveWheelEventHandlersAt(testing::_))
-      .WillOnce(testing::Return(false));
+  EXPECT_CALL(mock_input_handler_,
+              EffectiveWheelEventListenerPropertiesAt(testing::_))
+      .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_, PinchGestureBegin());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchUpdate;
   gesture_.data.pinchUpdate.scale = 1.5;
   gesture_.x = 7;
   gesture_.y = 13;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13)));
@@ skipping 27 matching lines @@
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GesturePinchWithWheelHandler) {
   // We will send the synthetic wheel event to the widget.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchBegin;
-  EXPECT_CALL(mock_input_handler_, HaveWheelEventHandlersAt(testing::_))
-      .WillOnce(testing::Return(true));
+  EXPECT_CALL(mock_input_handler_,
+              EffectiveWheelEventListenerPropertiesAt(testing::_))
+      .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchUpdate;
   gesture_.data.pinchUpdate.scale = 1.5;
   gesture_.x = 7;
   gesture_.y = 13;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
@@ skipping 27 matching lines @@
   gesture_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaY = 40;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // However, after the pinch gesture starts, they should go to the impl
   // thread.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchBegin;
-  EXPECT_CALL(mock_input_handler_, HaveWheelEventHandlersAt(testing::_))
-      .WillOnce(testing::Return(false));
+  EXPECT_CALL(mock_input_handler_,
+              EffectiveWheelEventListenerPropertiesAt(testing::_))
+      .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_, PinchGestureBegin());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchUpdate;
   gesture_.data.pinchUpdate.scale = 1.5;
   gesture_.x = 7;
   gesture_.y = 13;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13)));
@@ skipping 1057 matching lines @@
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 }
 
 TEST_P(InputHandlerProxyTest, MultiTouchPointHitTestNegative) {
   // None of the three touch points fall in the touch region. So the event
   // should be dropped.
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_,
-              DoTouchEventsBlockScrollAt(
+              EffectiveTouchEventListenerPropertiesAt(
                   testing::Property(&gfx::Point::x, testing::Gt(0))))
-      .WillOnce(testing::Return(false));
+      .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_,
-              DoTouchEventsBlockScrollAt(
+              EffectiveTouchEventListenerPropertiesAt(
                   testing::Property(&gfx::Point::x, testing::Lt(0))))
-      .WillOnce(testing::Return(false));
+      .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
 
   WebTouchEvent touch;
   touch.type = WebInputEvent::TouchStart;
 
   touch.touchesLength = 3;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StateStationary, 0, 0);
   touch.touches[1] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   touch.touches[2] = CreateWebTouchPoint(WebTouchPoint::StatePressed, -10, 10);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(touch));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, MultiTouchPointHitTestPositive) {
   // One of the touch points is on a touch-region. So the event should be sent
   // to the main thread.
-  expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
+  expected_disposition_ = InputHandlerProxy::NON_BLOCKING;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_,
-              DoTouchEventsBlockScrollAt(
-                  testing::Property(&gfx::Point::x, testing::Eq(0))))
-      .WillOnce(testing::Return(false));
+              EffectiveTouchEventListenerPropertiesAt(
+                  testing::Property(&gfx::Point::x, testing::Le(0))))
+      .WillRepeatedly(testing::Return(cc::EventListenerProperties::kNone));
   EXPECT_CALL(mock_input_handler_,
-              DoTouchEventsBlockScrollAt(
+              EffectiveTouchEventListenerPropertiesAt(
                   testing::Property(&gfx::Point::x, testing::Gt(0))))
-      .WillOnce(testing::Return(true));
+      .WillOnce(testing::Return(cc::EventListenerProperties::kPassive));
   // Since the second touch point hits a touch-region, there should be no
   // hit-testing for the third touch point.
 
   WebTouchEvent touch;
   touch.type = WebInputEvent::TouchStart;
 
   touch.touchesLength = 3;
   touch.touches[0] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 0, 0);
   touch.touches[1] = CreateWebTouchPoint(WebTouchPoint::StatePressed, 10, 10);
   touch.touches[2] = CreateWebTouchPoint(WebTouchPoint::StatePressed, -10, 10);
@@ skipping 676 matching lines @@
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler);
   testing::Mock::VerifyAndClearExpectations(&mock_client);
   testing::Mock::VerifyAndClearExpectations(&mock_synchronous_input_handler);
 }
 
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
 }  // namespace test
 }  // namespace ui