Track scroll event handlers in nested documents

Source/core/dom/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/dom/ActiveDOMObject.h"
 #include "core/dom/DocumentSupplementable.h"
 #include "core/events/Event.h"
 #include "wtf/HashCountedSet.h"
 
 namespace WebCore {
 
 typedef HashCountedSet<EventTarget*> EventTargetSet;
 
 // Registry for keeping track of event handlers. Handlers can either be
 // associated with an EventTarget or be "external" handlers which live outside
 // the DOM (e.g., WebViewImpl).
-class EventHandlerRegistry FINAL : public DocumentSupplement {
+class EventHandlerRegistry FINAL : public DocumentSupplement, private ActiveDOMObject {
 public:
     virtual ~EventHandlerRegistry();
 
     // Supported event handler classes. Note that each one may correspond to
     // multiple event types.
     enum EventHandlerClass {
         ScrollEvent,
         EventHandlerClassCount, // Must be the last entry.
     };
 
@@ skipping 15 matching lines @@
     void didAddEventHandler(EventTarget&, EventHandlerClass);
     void didRemoveEventHandler(EventTarget&, const AtomicString& eventType);
     void didRemoveEventHandler(EventTarget&, EventHandlerClass);
     void didMoveFromOtherDocument(EventTarget&, Document& oldDocument);
     void didRemoveAllEventHandlers(EventTarget&);
 
     virtual void trace(Visitor*) OVERRIDE { }
 
 private:
     explicit EventHandlerRegistry(Document&);
+    static EventHandlerRegistry* create(Document&);
 
     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.
     };
 
+    Document* document() const;
+
+    // Inherited from ActiveDOMObject
+    virtual void stop() OVERRIDE;
+
     // Returns true if |eventType| belongs to a class this registry tracks.
     static bool eventTypeToClass(const AtomicString& eventType, 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);
 
     // 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 updateEventHandlerInternal(ChangeOperation, EventHandlerClass, EventTarget*);
 
     struct HandlerState {
         HandlerState();
         ~HandlerState();
 
         OwnPtr<EventTargetSet> targets;
     };
 
-    Document& m_document;
     HandlerState m_eventHandlers[EventHandlerClassCount];
 };
 
 } // namespace WebCore
 
 #endif // EventHandlerRegistry_h