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)
+{
+    WebEventListenerProperties result = WebEventListenerProperties::Nothing;
+    if (hasBlocking)
+        result |= WebEventListenerProperties::Blocking;
+    if (hasPassive)
+        result |= WebEventListenerProperties::Passive;
+    return result;
+}
+
 } // 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 : WheelEvent;
     } else if (isTouchEventType(eventType)) {
-        *result = TouchEvent;
+        *result = options.passive() ? TouchEventPassive : TouchEvent;
     } 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;
+        *result = options.passive() ? TouchEventPassive : TouchEvent;

[Rick Byers, 2016/02/02 21:44:46]

Pointer events never block scrolling, so their listeners should always be
considered passive.

We need a test for this somewhere (but no need to block this CL on any
non-trivial pointer events related stuff since that's still work in progress -
but do file a bug).

[dtapuska, 2016/02/03 16:30:58]

Done.

 #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 15 matching lines @@
     }
 }
 
 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 WheelEventPassive:
+        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::MouseWheel, webEventListenerProperties(hasEventHandlers(WheelEvent), hasEventHandlers(WheelEventPassive)));
         break;
     case TouchEvent:
-        m_frameHost->chromeClient().needTouchEvents(hasActiveHandlers);
+    case TouchEventPassive:
+        m_frameHost->chromeClient().setEventListenerProperties(WebEventListenerClass::Touch, webEventListenerProperties(hasEventHandlers(TouchEvent), hasEventHandlers(TouchEventPassive)));
         break;
 #if ENABLE(ASSERT)
     case EventsForTesting:
         break;
 #endif
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
@@ skipping 75 matching lines @@
                 ASSERT(window->frame());
                 ASSERT(window->frame()->host());
                 ASSERT(window->frame()->host() == m_frameHost);
             }
         }
     }
 #endif // ENABLE(ASSERT)
 }
 
 } // namespace blink