Track scroll event handlers in nested documents

Source/core/dom/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 "config.h"
 #include "core/dom/EventHandlerRegistry.h"
 
 #include "core/dom/Document.h"
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/LocalFrame.h"
 #include "core/page/Chrome.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
 namespace WebCore {
 
+EventHandlerRegistry::DocumentObserver::DocumentObserver(Document& document)
+    : ActiveDOMObject(&document)
+{
+}
+
+EventHandlerRegistry::DocumentObserver::~DocumentObserver()
+{
+}
+
+void EventHandlerRegistry::DocumentObserver::stop()
+{
+    Document* document = static_cast<Document*>(lifecycleContext());
+    Document* parentDocument = document->parentDocument();
+    if (!parentDocument)
+        return;
+    EventHandlerRegistry* parentRegistry = EventHandlerRegistry::from(*parentDocument);
+    parentRegistry->didRemoveAllEventHandlers(*document);
+}
+
 EventHandlerRegistry::HandlerState::HandlerState()
 {
 }
 
 EventHandlerRegistry::HandlerState::~HandlerState()
 {
 }
 
 EventHandlerRegistry::EventHandlerRegistry(Document& document)
     : m_document(document)
+    , m_documentObserver(DocumentObserver(document))
 {
+    m_documentObserver.suspendIfNeeded();
 }
 
 EventHandlerRegistry::~EventHandlerRegistry()
 {
 }
 
 const char* EventHandlerRegistry::supplementName()
 {
     return "EventHandlerRegistry";
 }
@@ skipping 27 matching lines @@
 {
     EventTargetSet* targets = m_eventHandlers[handlerClass].targets.get();
     return targets && targets->size();
 }
 
 bool EventHandlerRegistry::updateEventHandlerTargets(ChangeOperation op, EventHandlerClass handlerClass, EventTarget* target)
 {
     EventTargetSet* targets = m_eventHandlers[handlerClass].targets.get();
     if (op == Add) {
 #if ASSERT_ENABLED
-        if (Node* node = target->toNode())
-            ASSERT(&node->document() == &m_document);
+        if (Node* node = target->toNode()) {
+            // The node should either be in the document, or be the Document node of a child
+            // of the document.
+            ASSERT(&node->document() == &m_document
+                || (node->isDocumentNode() && toDocument(node)->parentDocument() == &m_document));
+        }
 #endif // ASSERT_ENABLED
 
         if (!targets) {
             m_eventHandlers[handlerClass].targets = adoptPtr(new EventTargetSet);
             targets = m_eventHandlers[handlerClass].targets.get();
         }
 
         if (!targets->add(target).isNewEntry) {
             // Just incremented refcount, no real change.
+#if ASSERT_ENABLED
+            // If this is a child document node, then the count should never go above 1.
+            if (Node* node = target->toNode())
+                ASSERT(!node->isDocumentNode() || &node->document() == &m_document);
+#endif // ASSERT_ENABLED
             return false;
         }
     } else {
         // Note that we can't assert that |target| is in this document because
         // it might be in the process of moving out of it.
         ASSERT(op == Remove || op == RemoveAll);
         ASSERT(op == RemoveAll || targets->contains(target));
         if (!targets)
             return false;
 
         if (op == RemoveAll) {
             if (!targets->contains(target))
                 return false;
             targets->removeAll(target);
         } else {
             if (!targets->remove(target)) {
                 // Just decremented refcount, no real update.
                 return false;
             }
         }
     }
     return true;
 }
 
 void EventHandlerRegistry::updateEventHandlerInternal(ChangeOperation op, EventHandlerClass handlerClass, EventTarget* target)
 {
-    // After the document has stopped, all updates become no-ops.
-    if (!m_document.isActive()) {
-        return;
-    }
+    // Notify our parent registry if we added the first or removed the last handler.
+    for (Document* document = &m_document; document; document = document->parentDocument()) {
+        // After the document has stopped, all updates become no-ops.
+        if (!document->isActive()) {
+            return;
+        }
+        EventHandlerRegistry* registry = EventHandlerRegistry::from(*document);
 
-    bool hadHandlers = hasEventHandlers(handlerClass);
-    updateEventHandlerTargets(op, handlerClass, target);
-    bool hasHandlers = hasEventHandlers(handlerClass);
+        bool hadHandlers = registry->hasEventHandlers(handlerClass);
+        registry->updateEventHandlerTargets(op, handlerClass, target);
+        bool hasHandlers = registry->hasEventHandlers(handlerClass);
 
-    // Notify the parent document's registry if we added the first or removed
-    // the last handler.
-    if (hadHandlers != hasHandlers && !m_document.parentDocument()) {
-        // This is the root registry; notify clients accordingly.
-        notifyHasHandlersChanged(handlerClass, hasHandlers);
+        if (hadHandlers == hasHandlers) {
+            break;
+        }
+        if (!document->parentDocument()) {
+            // This is the root registry; notify clients accordingly.
+            registry->notifyHasHandlersChanged(handlerClass, hasHandlers);
+        } else {
+            // Report change to parent with our Document as the target.
+            target = document;
+        }
     }
 }
 
 void EventHandlerRegistry::updateEventHandlerOfType(ChangeOperation op, const AtomicString& eventType, EventTarget* target)
 {
     EventHandlerClass handlerClass;
     if (!eventTypeToClass(eventType, &handlerClass))
         return;
     updateEventHandlerInternal(op, handlerClass, target);
 }
@@ skipping 54 matching lines @@
         if (scrollingCoordinator)
             scrollingCoordinator->updateHaveScrollEventHandlers();
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 } // namespace WebCore