Migrate touch events to EventHandlerRegistry

Source/core/frame/EventHandlerRegistry.cpp

Index: Source/core/frame/EventHandlerRegistry.cpp
diff --git a/Source/core/frame/EventHandlerRegistry.cpp b/Source/core/frame/EventHandlerRegistry.cpp
index 478ce65904bdb1af7e12f1fe21ad465f5021fc4b..4f7be781efaaa77f1bd3e3f92df48394816cf8e4 100644
--- a/Source/core/frame/EventHandlerRegistry.cpp
+++ b/Source/core/frame/EventHandlerRegistry.cpp
@@ -9,6 +9,8 @@
 #include "core/frame/DOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFrameOwnerElement.h"
+#include "core/page/Chrome.h"
+#include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
@@ -30,6 +32,8 @@ bool EventHandlerRegistry::eventTypeToClass(const AtomicString& eventType, Event
         *result = ScrollEvent;
     } else if (eventType == EventTypeNames::wheel || eventType == EventTypeNames::mousewheel) {
         *result = WheelEvent;
+    } else if (isTouchEventType(eventType)) {
+        *result = TouchEvent;
 #if ASSERT_ENABLED
     } else if (eventType == EventTypeNames::load || eventType == EventTypeNames::mousemove || eventType == EventTypeNames::touchstart) {
         *result = EventsForTesting;
@@ -48,6 +52,7 @@ const EventTargetSet* EventHandlerRegistry::eventHandlerTargets(EventHandlerClas
 
 bool EventHandlerRegistry::hasEventHandlers(EventHandlerClass handlerClass) const
 {
+    checkConsistency();
     return m_targets[handlerClass].size();
 }
 
@@ -79,14 +84,15 @@ bool EventHandlerRegistry::updateEventHandlerTargets(ChangeOperation op, EventHa
 
 void EventHandlerRegistry::updateEventHandlerInternal(ChangeOperation op, EventHandlerClass handlerClass, EventTarget* target)
 {
-    bool hadHandlers = hasEventHandlers(handlerClass);
-    updateEventHandlerTargets(op, handlerClass, target);
-    bool hasHandlers = hasEventHandlers(handlerClass);
+    bool hadHandlers = m_targets[handlerClass].size();
+    bool targetSetChanged = updateEventHandlerTargets(op, handlerClass, target);
+    bool hasHandlers = m_targets[handlerClass].size();
 
-    if (hadHandlers != hasHandlers) {
+    if (hadHandlers != hasHandlers)
         notifyHasHandlersChanged(handlerClass, hasHandlers);
-    }
-    checkConsistency();
+
+    if (targetSetChanged)
+        notifyDidAddOrRemoveEventHandlerTarget(handlerClass);
 }
 
 void EventHandlerRegistry::updateEventHandlerOfType(ChangeOperation op, const AtomicString& eventType, EventTarget* target)
@@ -117,14 +123,33 @@ void EventHandlerRegistry::didRemoveEventHandler(EventTarget& target, EventHandl
     updateEventHandlerInternal(Remove, handlerClass, &target);
 }
 
-void EventHandlerRegistry::didMoveIntoFrameHost(EventTarget& target)
+void EventHandlerRegistry::didMoveBetweenFrameHosts(EventTarget& target, FrameHost* oldFrameHost, FrameHost* newFrameHost)
 {
-    updateAllEventHandlers(Add, target);
-}
+    ASSERT(newFrameHost || oldFrameHost);
+    ASSERT(newFrameHost != oldFrameHost);
+    if (newFrameHost && !oldFrameHost) {

[Rick Byers, 2014/06/19 17:10:36]

this code reads like it should really be 3 functions (none of which permit null
arguments), not one function with 3 overloaded scenarios. 

[Sami, 2014/06/27 17:58:51]

Agreed, let me clean this up.

[Rick Byers, 2014/06/27 21:36:51]

Looks better, thanks.

+        if (!target.hasEventListeners())
+            return;
 
-void EventHandlerRegistry::didMoveOutOfFrameHost(EventTarget& target)
-{
-    updateAllEventHandlers(RemoveAll, target);
+        Vector<AtomicString> eventTypes = target.eventTypes();
+        for (size_t i = 0; i < eventTypes.size(); ++i) {
+            EventHandlerClass handlerClass;
+            if (!eventTypeToClass(eventTypes[i], &handlerClass))
+                continue;
+            for (unsigned count = target.getEventListeners(eventTypes[i]).size(); count > 0; --count)
+                newFrameHost->eventHandlerRegistry().didAddEventHandler(target, handlerClass);
+        }
+    } else if (!newFrameHost && oldFrameHost) {
+        oldFrameHost->eventHandlerRegistry().didRemoveAllEventHandlers(target);
+    } else if (newFrameHost && oldFrameHost) {
+        for (size_t i = 0; i < EventHandlerClassCount; ++i) {
+            EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
+            const EventTargetSet* targets = &oldFrameHost->eventHandlerRegistry().m_targets[handlerClass];
+            for (unsigned count = targets->count(&target); count > 0; --count)
+                newFrameHost->eventHandlerRegistry().didAddEventHandler(target, handlerClass);
+            oldFrameHost->eventHandlerRegistry().didRemoveAllEventHandlers(target);
+        }
+    }
 }
 
 void EventHandlerRegistry::didRemoveAllEventHandlers(EventTarget& target)
@@ -135,25 +160,6 @@ void EventHandlerRegistry::didRemoveAllEventHandlers(EventTarget& target)
     }
 }
 
-void EventHandlerRegistry::updateAllEventHandlers(ChangeOperation op, EventTarget& target)
-{
-    if (!target.hasEventListeners())
-        return;
-
-    Vector<AtomicString> eventTypes = target.eventTypes();
-    for (size_t i = 0; i < eventTypes.size(); ++i) {
-        EventHandlerClass handlerClass;
-        if (!eventTypeToClass(eventTypes[i], &handlerClass))
-            continue;
-        if (op == RemoveAll) {
-            updateEventHandlerInternal(op, handlerClass, &target);
-            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();
@@ -167,6 +173,9 @@ void EventHandlerRegistry::notifyHasHandlersChanged(EventHandlerClass handlerCla
         if (scrollingCoordinator)
             scrollingCoordinator->updateHaveWheelEventHandlers();
         break;
+    case TouchEvent:
+        m_frameHost.chrome().client().needTouchEvents(hasActiveHandlers);
+        break;
 #if ASSERT_ENABLED
     case EventsForTesting:
         break;
@@ -177,6 +186,13 @@ void EventHandlerRegistry::notifyHasHandlersChanged(EventHandlerClass handlerCla
     }
 }
 
+void EventHandlerRegistry::notifyDidAddOrRemoveEventHandlerTarget(EventHandlerClass handlerClass)
+{
+    ScrollingCoordinator* scrollingCoordinator = m_frameHost.page().scrollingCoordinator();
+    if (scrollingCoordinator && handlerClass == TouchEvent)
+        scrollingCoordinator->touchEventTargetRectsDidChange();
+}
+
 void EventHandlerRegistry::trace(Visitor* visitor)
 {
     visitor->registerWeakMembers<EventHandlerRegistry, &EventHandlerRegistry::clearWeakMembers>(this);