Add EventHandlerRegistry

Source/core/dom/EventHandlerRegistry.h

Index: Source/core/dom/EventHandlerRegistry.h
diff --git a/Source/core/dom/EventHandlerRegistry.h b/Source/core/dom/EventHandlerRegistry.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e761c225f3f6a02758290eeaba6b530a57265b6
--- /dev/null
+++ b/Source/core/dom/EventHandlerRegistry.h
@@ -0,0 +1,60 @@
+// 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/DocumentSupplementable.h"
+#include "core/events/Event.h"
+#include "core/frame/DOMWindowLifecycleObserver.h"
+#include "wtf/HashCountedSet.h"
+
+namespace WebCore {
+
+class DOMWindow;
+
+typedef HashCountedSet<Node*> TouchEventTargetSet;
+
+class EventHandlerRegistry FINAL : public DocumentSupplement, public DOMWindowLifecycleObserver {

[Rick Byers, 2014/03/24 14:27:59]

I really like the fact that you're unifying this event handler tracking across
different types of events!

I think ideally there'd be no reason for this class to know details of specific
event types at all (it could do completely generic event handler tracking). 
That's probably too much work right now (there are going to be some special
cases and it's probably not worth the indirection/abstraction to remove all
detail of them from this class).  But it does seem like a good idea to work
towards that wherever it can be done cleanly.

For example, define a 'EventHandlerClass' enum (currently WheelEvent,
ScrollEvent or TouchEvent).  Then rather than have any 'fooEventHandlerCount'
functions, you can have just 'eventHandlerCount' that takes the class as a
parameter.

At the moment touch event handlers are special in that we need to be able to
enumerate all the nodes, but that probably doesn't need to be baked in (I could
see wanting that for wheel handlers too, etc.).  Perhaps each event class should
just have a constant bit saying whether we want to take the time to track all
the handler nodes (or just keep a dumb count).  At some point I could see
enabling this in debug for all handler classes since the touch-handler related
ASSERTS have been super-valuable in finding edge cases where the handlers
weren't being tracked properly.

+public:
+    virtual ~EventHandlerRegistry();
+
+    static const char* supplementName();
+    static EventHandlerRegistry* from(Document&);
+
+    unsigned scrollEventHandlerCount() const { return m_scrollEventHandlerCount; }
+    unsigned wheelEventHandlerCount() const { return m_wheelEventHandlerCount; }
+
+    // Node: Handlers added/removed from the DOMWindow are reported as the Document.
+    const TouchEventTargetSet* touchEventTargets() const { return m_touchEventTargets.get(); }
+
+    static void didRemoveAllEventHandlers(Node&);
+    static void didMoveNodeToNewDocument(Node&, Document& oldDocument);
+
+    void didAddEventHandler(Document&, const AtomicString&, Node*);
+    void didRemoveEventHandler(Document&, const AtomicString&, Node*);
+
+    // Inherited from DOMWindowLifecycleObserver
+    virtual void didAddEventListener(DOMWindow*, const AtomicString&) OVERRIDE;
+    virtual void didRemoveEventListener(DOMWindow*, const AtomicString&) OVERRIDE;
+
+private:
+    explicit EventHandlerRegistry(Document&);
+
+    void didChangeWheelEventHandlerCount(Document&, int delta);
+    void didChangeScrollEventHandlerCount(Document&, int delta);
+
+    void didAddTouchEventHandler(Document&, Node&);
+    void didRemoveTouchEventHandler(Document&, Node&, bool clearAll);
+
+    enum ChangeOperation { Added, Removed, RemovedAll };
+    static void didChangeAllEventHandlers(Node&, Document&, ChangeOperation);
+
+    unsigned m_scrollEventHandlerCount;
+    unsigned m_wheelEventHandlerCount;
+    OwnPtr<TouchEventTargetSet> m_touchEventTargets;
+};
+
+} // namespace WebCore
+
+#endif // EventHandlerRegistry_h