Communicate whether passive event listeners exist to cc.

third_party/WebKit/Source/core/frame/EventHandlerRegistry.cpp

 // Copyright 2014 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 "core/frame/EventHandlerRegistry.h"
 
+#include "core/events/EventListenerOptions.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
 namespace blink {
 
 namespace {
@@ skipping 13 matching lines @@
         || eventType == EventTypeNames::pointercancel
         || eventType == EventTypeNames::pointerdown
         || eventType == EventTypeNames::pointerenter
         || eventType == EventTypeNames::pointerleave
         || eventType == EventTypeNames::pointermove
         || eventType == EventTypeNames::pointerout
         || eventType == EventTypeNames::pointerover
         || eventType == EventTypeNames::pointerup;
 }
 
+WebEventListenerProperties webEventListenerProperties(bool hasBlocking, bool hasPassive)
+{
+    if (hasBlocking)
+        return WebEventListenerProperties::Blocking;
+    if (hasPassive)
+        return WebEventListenerProperties::Passive;
+    return WebEventListenerProperties::Nothing;
+}
+
 } // namespace
 
 EventHandlerRegistry::EventHandlerRegistry(FrameHost& frameHost)
     : m_frameHost(&frameHost)
 {
 }
 
 EventHandlerRegistry::~EventHandlerRegistry()
 {
     checkConsistency();
 }
 
-bool EventHandlerRegistry::eventTypeToClass(const AtomicString& eventType, EventHandlerClass* result)
+bool EventHandlerRegistry::eventTypeToClass(const AtomicString& eventType, const EventListenerOptions& options, EventHandlerClass* result)
 {
     if (eventType == EventTypeNames::scroll) {
         *result = ScrollEvent;
     } else if (eventType == EventTypeNames::wheel || eventType == EventTypeNames::mousewheel) {
-        *result = WheelEvent;
+        *result = options.passive() ? WheelEventPassive : WheelEventBlocking;
     } else if (isTouchEventType(eventType)) {
-        *result = TouchEvent;
+        *result = options.passive() ? TouchEventPassive : TouchEventBlocking;
     } else if (isPointerEventType(eventType)) {
-        // The EventHandlerClass is still TouchEvent below since we are firing PointerEvents only from
-        // EventHandler::handleTouchEvent for now. See crbug.com/476565.
-        *result = TouchEvent;
+        // The EventHandlerClass is TouchEventPassive since the events
+        // do not block scrolling and only the compositor cares
+        // about touch events for now.

[Rick Byers, 2016/02/04 22:18:57]

nit: I'm confused by the "for now".  The compositor cares only about touch
listeners precisely because it's only touch listeners that can block gesture
scrolls.  So maybe reword as "since pointer events never block scrolling and so
the compositor only needs to know about the touch listeners"?

+        *result = TouchEventPassive;
 #if ENABLE(ASSERT)
     } else if (eventType == EventTypeNames::load || eventType == EventTypeNames::mousemove || eventType == EventTypeNames::touchstart) {
         *result = EventsForTesting;
 #endif
     } else {
         return false;
     }
     return true;
 }
 
@@ skipping 41 matching lines @@
     bool targetSetChanged = updateEventHandlerTargets(op, handlerClass, target);
     bool hasHandlers = m_targets[handlerClass].size();
 
     if (hadHandlers != hasHandlers)
         notifyHasHandlersChanged(handlerClass, hasHandlers);
 
     if (targetSetChanged)
         notifyDidAddOrRemoveEventHandlerTarget(handlerClass);
 }
 
-void EventHandlerRegistry::updateEventHandlerOfType(ChangeOperation op, const AtomicString& eventType, EventTarget* target)
+void EventHandlerRegistry::updateEventHandlerOfType(ChangeOperation op, const AtomicString& eventType, const EventListenerOptions& options, EventTarget* target)
 {
     EventHandlerClass handlerClass;
-    if (!eventTypeToClass(eventType, &handlerClass))
+    if (!eventTypeToClass(eventType, options, &handlerClass))
         return;
     updateEventHandlerInternal(op, handlerClass, target);
 }
 
-void EventHandlerRegistry::didAddEventHandler(EventTarget& target, const AtomicString& eventType)
+void EventHandlerRegistry::didAddEventHandler(EventTarget& target, const AtomicString& eventType, const EventListenerOptions& options)
 {
-    updateEventHandlerOfType(Add, eventType, &target);
+    updateEventHandlerOfType(Add, eventType, options, &target);
 }
 
-void EventHandlerRegistry::didRemoveEventHandler(EventTarget& target, const AtomicString& eventType)
+void EventHandlerRegistry::didRemoveEventHandler(EventTarget& target, const AtomicString& eventType, const EventListenerOptions& options)
 {
-    updateEventHandlerOfType(Remove, eventType, &target);
+    updateEventHandlerOfType(Remove, eventType, options, &target);
 }
 
 void EventHandlerRegistry::didAddEventHandler(EventTarget& target, EventHandlerClass handlerClass)
 {
     updateEventHandlerInternal(Add, handlerClass, &target);
 }
 
 void EventHandlerRegistry::didRemoveEventHandler(EventTarget& target, EventHandlerClass handlerClass)
 {
     updateEventHandlerInternal(Remove, handlerClass, &target);
 }
 
 void EventHandlerRegistry::didMoveIntoFrameHost(EventTarget& target)
 {
     if (!target.hasEventListeners())
         return;
 
+    // This code is not efficient at all.
     Vector<AtomicString> eventTypes = target.eventTypes();
     for (size_t i = 0; i < eventTypes.size(); ++i) {
-        EventHandlerClass handlerClass;
-        if (!eventTypeToClass(eventTypes[i], &handlerClass))
-            continue;
         EventListenerVector* listeners = target.getEventListeners(eventTypes[i]);
         if (!listeners)
             continue;
-        for (unsigned count = listeners->size(); count > 0; --count)
+        for (unsigned count = listeners->size(); count > 0; --count) {
+            EventHandlerClass handlerClass;
+            if (!eventTypeToClass(eventTypes[i], (*listeners)[count - 1].options(), &handlerClass))
+                continue;
+
             didAddEventHandler(target, handlerClass);
+        }
     }
 }
 
 void EventHandlerRegistry::didMoveOutOfFrameHost(EventTarget& target)
 {
     didRemoveAllEventHandlers(target);
 }
 
 void EventHandlerRegistry::didMoveBetweenFrameHosts(EventTarget& target, FrameHost* oldFrameHost, FrameHost* newFrameHost)
 {
@@ skipping 14 matching lines @@
         updateEventHandlerInternal(RemoveAll, handlerClass, &target);
     }
 }
 
 void EventHandlerRegistry::notifyHasHandlersChanged(EventHandlerClass handlerClass, bool hasActiveHandlers)
 {
     switch (handlerClass) {
     case ScrollEvent:
         m_frameHost->chromeClient().setHaveScrollEventHandlers(hasActiveHandlers);
         break;
-    case WheelEvent:
-        m_frameHost->chromeClient().setHaveWheelEventHandlers(hasActiveHandlers);
+    case WheelEventBlocking:
+    case WheelEventPassive:
+        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::MouseWheel, webEventListenerProperties(hasEventHandlers(WheelEventBlocking), hasEventHandlers(WheelEventPassive)));
         break;
-    case TouchEvent:
-        m_frameHost->chromeClient().needTouchEvents(hasActiveHandlers);
+    case TouchEventBlocking:
+    case TouchEventPassive:
+        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::Touch, webEventListenerProperties(hasEventHandlers(TouchEventBlocking), hasEventHandlers(TouchEventPassive)));
         break;
 #if ENABLE(ASSERT)
     case EventsForTesting:
         break;
 #endif
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 void EventHandlerRegistry::notifyDidAddOrRemoveEventHandlerTarget(EventHandlerClass handlerClass)
 {
     ScrollingCoordinator* scrollingCoordinator = m_frameHost->page().scrollingCoordinator();
-    if (scrollingCoordinator && handlerClass == TouchEvent)
+    if (scrollingCoordinator && handlerClass == TouchEventBlocking)
         scrollingCoordinator->touchEventTargetRectsDidChange();
 }
 
 DEFINE_TRACE(EventHandlerRegistry)
 {
     visitor->trace(m_frameHost);
     visitor->template registerWeakMembers<EventHandlerRegistry, &EventHandlerRegistry::clearWeakMembers>(this);
 }
 
 void EventHandlerRegistry::clearWeakMembers(Visitor* visitor)
@@ skipping 60 matching lines @@
                 ASSERT(window->frame());
                 ASSERT(window->frame()->host());
                 ASSERT(window->frame()->host() == m_frameHost);
             }
         }
     }
 #endif // ENABLE(ASSERT)
 }
 
 } // namespace blink