Communicate whether passive event listeners exist to cc.

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

 // 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.
 
 #ifndef EventHandlerRegistry_h
 #define EventHandlerRegistry_h
 
 #include "core/CoreExport.h"
 #include "core/frame/FrameHost.h"
 #include "wtf/HashCountedSet.h"
 
 namespace blink {
 
 class Document;
+class EventListenerOptions;
 class EventTarget;
 
 typedef HashCountedSet<RawPtrWillBeUntracedMember<EventTarget>> EventTargetSet;
 
 // Registry for keeping track of event handlers. Note that only handlers on
 // documents that can be rendered or can receive input (i.e., are attached to a
 // FrameHost) are registered here.
 class CORE_EXPORT EventHandlerRegistry final : public NoBaseWillBeGarbageCollectedFinalized<EventHandlerRegistry> {
     USING_FAST_MALLOC_WILL_BE_REMOVED(EventHandlerRegistry);
 public:
     explicit EventHandlerRegistry(FrameHost&);
     virtual ~EventHandlerRegistry();
 
     // Supported event handler classes. Note that each one may correspond to
     // multiple event types.
     enum EventHandlerClass {
         ScrollEvent,
         WheelEvent,

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

nit rename this to WheelEventBlocking, and TouchEvent to TouchEventBlocking to
make it clear that Passive is not a subset of the total, and to ensure we're
actually updating the expectations of all the consumers (in many cases it's no
longer sufficient to just ask if there are any 'WheelEvent' listeners).

+        WheelEventPassive,
         TouchEvent,
+        TouchEventPassive,
 #if ENABLE(ASSERT)
         // Additional event categories for verifying handler tracking logic.
         EventsForTesting,
 #endif
         EventHandlerClassCount, // Must be the last entry.
     };
 
     // Returns true if the FrameHost has event handlers of the specified class.
     bool hasEventHandlers(EventHandlerClass) const;
 
     // Returns a set of EventTargets which have registered handlers of the given class.
     const EventTargetSet* eventHandlerTargets(EventHandlerClass) const;
 
     // Registration and management of event handlers attached to EventTargets.
-    void didAddEventHandler(EventTarget&, const AtomicString& eventType);
+    void didAddEventHandler(EventTarget&, const AtomicString& eventType, const EventListenerOptions&);
     void didAddEventHandler(EventTarget&, EventHandlerClass);
-    void didRemoveEventHandler(EventTarget&, const AtomicString& eventType);
+    void didRemoveEventHandler(EventTarget&, const AtomicString& eventType, const EventListenerOptions&);
     void didRemoveEventHandler(EventTarget&, EventHandlerClass);
     void didRemoveAllEventHandlers(EventTarget&);
 
     void didMoveIntoFrameHost(EventTarget&);
     void didMoveOutOfFrameHost(EventTarget&);
     static void didMoveBetweenFrameHosts(EventTarget&, FrameHost* oldFrameHost, FrameHost* newFrameHost);
 
     // Either |documentDetached| or |didMove{Into,OutOf,Between}FrameHosts| must
     // be called whenever the FrameHost that is associated with a registered event
     // target changes. This ensures the registry does not end up with stale
     // references to handlers that are no longer related to it.
     void documentDetached(Document&);
 
     DECLARE_TRACE();
     void clearWeakMembers(Visitor*);
 
 private:
     enum ChangeOperation {
         Add, // Add a new event handler.
         Remove, // Remove an existing event handler.
         RemoveAll // Remove any and all existing event handlers for a given target.
     };
 
     // Returns true if |eventType| belongs to a class this registry tracks.
-    static bool eventTypeToClass(const AtomicString& eventType, EventHandlerClass* result);
+    static bool eventTypeToClass(const AtomicString& eventType, const EventListenerOptions&, EventHandlerClass* result);
 
     // Returns true if the operation actually added a new target or completely
     // removed an existing one.
     bool updateEventHandlerTargets(ChangeOperation, EventHandlerClass, EventTarget*);
 
     // Called on the EventHandlerRegistry of the root Document to notify
     // clients when we have added the first handler or removed the last one for
     // a given event class. |hasActiveHandlers| can be used to distinguish
     // between the two cases.
     void notifyHasHandlersChanged(EventHandlerClass, bool hasActiveHandlers);
 
     // Called to notify clients whenever a single event handler target is
     // registered or unregistered. If several handlers are registered for the
     // same target, only the first registration will trigger this notification.
     void notifyDidAddOrRemoveEventHandlerTarget(EventHandlerClass);
 
     // Record a change operation to a given event handler class and notify any
     // parent registry and other clients accordingly.
-    void updateEventHandlerOfType(ChangeOperation, const AtomicString& eventType, EventTarget*);
+    void updateEventHandlerOfType(ChangeOperation, const AtomicString& eventType, const EventListenerOptions&, EventTarget*);
 
     void updateEventHandlerInternal(ChangeOperation, EventHandlerClass, EventTarget*);
 
     void updateAllEventHandlers(ChangeOperation, EventTarget&);
 
     void checkConsistency() const;
 
     RawPtrWillBeMember<FrameHost> m_frameHost;
     EventTargetSet m_targets[EventHandlerClassCount];
 };
 
 } // namespace blink
 
 #endif // EventHandlerRegistry_h