Migrate wheel events to EventHandlerRegistry

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 "config.h"
 #include "core/frame/EventHandlerRegistry.h"
 
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
 namespace WebCore {
 
+EventHandlerRegistry::HandlerState::HandlerState()
+    : externalHandlerCount(0)
+{
+}
+
+EventHandlerRegistry::HandlerState::~HandlerState()
+{
+}
+
 EventHandlerRegistry::EventHandlerRegistry(FrameHost& frameHost)
     : m_frameHost(frameHost)
 {
 }
 
 EventHandlerRegistry::~EventHandlerRegistry()
 {
     checkConsistency();
 }
 
 bool EventHandlerRegistry::eventTypeToClass(const AtomicString& eventType, EventHandlerClass* result)
 {
     if (eventType == EventTypeNames::scroll) {
         *result = ScrollEvent;
+    } else if (eventType == EventTypeNames::wheel || eventType == EventTypeNames::mousewheel) {
+        *result = WheelEvent;
 #if ASSERT_ENABLED
     } else if (eventType == EventTypeNames::load || eventType == EventTypeNames::mousemove || eventType == EventTypeNames::touchstart) {
         *result = EventsForTesting;
 #endif
     } else {
         return false;
     }
     return true;
 }
 
 const EventTargetSet* EventHandlerRegistry::eventHandlerTargets(EventHandlerClass handlerClass) const
 {
     checkConsistency();
-    return &m_targets[handlerClass];
+    return &m_handlers[handlerClass].targets;
+}
+
+unsigned EventHandlerRegistry::externalEventHandlerCount(EventHandlerClass handlerClass) const
+{
+    return m_handlers[handlerClass].externalHandlerCount;
 }
 
 bool EventHandlerRegistry::hasEventHandlers(EventHandlerClass handlerClass) const
 {
-    return m_targets[handlerClass].size();
+    const HandlerState& state = m_handlers[handlerClass];
+    return state.targets.size() || state.externalHandlerCount;
+}
+
+void EventHandlerRegistry::updateExternalHandlerCount(ChangeOperation op, EventHandlerClass handlerClass)
+{
+    if (op == Add) {
+        m_handlers[handlerClass].externalHandlerCount++;
+    } else {
+        ASSERT(op == Remove);
+        ASSERT(m_handlers[handlerClass].externalHandlerCount > 0);
+        m_handlers[handlerClass].externalHandlerCount--;
+    }
 }
 
 bool EventHandlerRegistry::updateEventHandlerTargets(ChangeOperation op, EventHandlerClass handlerClass, EventTarget* target)
 {
-    EventTargetSet* targets = &m_targets[handlerClass];
+    EventTargetSet* targets = &m_handlers[handlerClass].targets;
     if (op == Add) {
         if (!targets->add(target).isNewEntry) {
             // Just incremented refcount, no real change.
             return false;
         }
     } else {
         ASSERT(op == Remove || op == RemoveAll);
         ASSERT(op == RemoveAll || targets->contains(target));
 
         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)
 {
     bool hadHandlers = hasEventHandlers(handlerClass);
-    updateEventHandlerTargets(op, handlerClass, target);
+    if (target) {
+        updateEventHandlerTargets(op, handlerClass, target);
+    } else {
+        updateExternalHandlerCount(op, handlerClass);
+    }
     bool hasHandlers = hasEventHandlers(handlerClass);
 
     if (hadHandlers != hasHandlers) {
         notifyHasHandlersChanged(handlerClass, hasHandlers);
     }
     checkConsistency();
 }
 
 void EventHandlerRegistry::updateEventHandlerOfType(ChangeOperation op, const AtomicString& eventType, EventTarget* target)
 {
     EventHandlerClass handlerClass;
     if (!eventTypeToClass(eventType, &handlerClass))
         return;
     updateEventHandlerInternal(op, handlerClass, target);
 }
 
+void EventHandlerRegistry::didAddExternalEventHandler(const AtomicString& eventType)
+{
+    updateEventHandlerOfType(Add, eventType, 0);
+}
+
+void EventHandlerRegistry::didRemoveExternalEventHandler(const AtomicString& eventType)
+{
+    updateEventHandlerOfType(Remove, eventType, 0);
+}
+
 void EventHandlerRegistry::didAddEventHandler(EventTarget& target, const AtomicString& eventType)
 {
     updateEventHandlerOfType(Add, eventType, &target);
 }
 
 void EventHandlerRegistry::didRemoveEventHandler(EventTarget& target, const AtomicString& eventType)
 {
     updateEventHandlerOfType(Remove, eventType, &target);
 }
 
@@ skipping 40 matching lines @@
             continue;
         }
         for (unsigned count = target.getEventListeners(eventTypes[i]).size(); count > 0; --count)
             updateEventHandlerInternal(op, handlerClass, &target);
     }
 }
 
 void EventHandlerRegistry::notifyHasHandlersChanged(EventHandlerClass handlerClass, bool hasActiveHandlers)
 {
     ScrollingCoordinator* scrollingCoordinator = m_frameHost.page().scrollingCoordinator();
+    LocalFrame* mainFrame = m_frameHost.page().mainFrame();
 
     switch (handlerClass) {
     case ScrollEvent:
         if (scrollingCoordinator)
             scrollingCoordinator->updateHaveScrollEventHandlers();
         break;
+    case WheelEvent:
+        if (mainFrame) {
+            // TODO(skyostil): This notification is wired up to a black hole, so remove it.
+            mainFrame->notifyChromeClientWheelEventHandlerCountChanged();
+        }
+        if (scrollingCoordinator)
+            scrollingCoordinator->updateHaveWheelEventHandlers();
+        break;
 #if ASSERT_ENABLED
     case EventsForTesting:
         break;
 #endif
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 void EventHandlerRegistry::trace(Visitor* visitor)
 {
     visitor->registerWeakMembers<EventHandlerRegistry, &EventHandlerRegistry::clearWeakMembers>(this);
 }
 
 void EventHandlerRegistry::clearWeakMembers(Visitor* visitor)
 {
     Vector<EventTarget*> deadTargets;
     for (size_t i = 0; i < EventHandlerClassCount; ++i) {
         EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
-        const EventTargetSet* targets = &m_targets[handlerClass];
+        const EventTargetSet* targets = &m_handlers[handlerClass].targets;
         for (EventTargetSet::const_iterator it = targets->begin(); it != targets->end(); ++it) {
             Node* node = it->key->toNode();
             DOMWindow* window = it->key->toDOMWindow();
             if (node && !visitor->isAlive(node)) {
                 deadTargets.append(node);
             } else if (window && !visitor->isAlive(window)) {
                 deadTargets.append(window);
             }
         }
     }
     for (size_t i = 0; i < deadTargets.size(); ++i)
         didRemoveAllEventHandlers(*deadTargets[i]);
 }
 
 void EventHandlerRegistry::documentDetached(Document& document)
 {
     // Remove all event targets under the detached document.
     for (size_t handlerClassIndex = 0; handlerClassIndex < EventHandlerClassCount; ++handlerClassIndex) {
         EventHandlerClass handlerClass = static_cast<EventHandlerClass>(handlerClassIndex);
         Vector<EventTarget*> targetsToRemove;
-        const EventTargetSet* targets = &m_targets[handlerClass];
+        const EventTargetSet* targets = &m_handlers[handlerClass].targets;
         for (EventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
             if (Node* node = iter->key->toNode()) {
                 for (Document* doc = &node->document(); doc; doc = doc->ownerElement() ? &doc->ownerElement()->document() : 0) {
                     if (doc == &document) {
                         targetsToRemove.append(iter->key);
                         break;
                     }
                 }
             } else if (iter->key->toDOMWindow()) {
                 // DOMWindows may outlive their documents, so we shouldn't remove their handlers
                 // here.
             } else {
                 ASSERT_NOT_REACHED();
             }
         }
         for (size_t i = 0; i < targetsToRemove.size(); ++i)
             updateEventHandlerInternal(RemoveAll, handlerClass, targetsToRemove[i]);
     }
 }
 
 void EventHandlerRegistry::checkConsistency() const
 {
 #if ASSERT_ENABLED
     for (size_t i = 0; i < EventHandlerClassCount; ++i) {
         EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
-        const EventTargetSet* targets = &m_targets[handlerClass];
+        const EventTargetSet* targets = &m_handlers[handlerClass].targets;
         for (EventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
             if (Node* node = iter->key->toNode()) {
                 // See the comment for |documentDetached| if either of these assertions fails.
                 ASSERT(node->document().frameHost());
                 ASSERT(node->document().frameHost() == &m_frameHost);
             } else if (DOMWindow* window = iter->key->toDOMWindow()) {
                 // If any of these assertions fail, DOMWindow failed to unregister its handlers
                 // properly.
                 ASSERT(window->frame());
                 ASSERT(window->frame()->host());
                 ASSERT(window->frame()->host() == &m_frameHost);
             }
         }
     }
 #endif // ASSERT_ENABLED
 }
 
 } // namespace WebCore