Revert 177812 "Migrate touch events to EventHandlerRegistry"

trunk/Source/core/frame/EventHandlerRegistry.cpp

Index: trunk/Source/core/frame/EventHandlerRegistry.cpp
===================================================================
--- trunk/Source/core/frame/EventHandlerRegistry.cpp	(revision 177995)
+++ trunk/Source/core/frame/EventHandlerRegistry.cpp	(working copy)
@@ -9,8 +9,6 @@
 #include "core/frame/LocalDOMWindow.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"
 
@@ -32,8 +30,6 @@
         *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;
@@ -52,7 +48,6 @@
 
 bool EventHandlerRegistry::hasEventHandlers(EventHandlerClass handlerClass) const
 {
-    checkConsistency();
     return m_targets[handlerClass].size();
 }
 
@@ -84,15 +79,14 @@
 
 void EventHandlerRegistry::updateEventHandlerInternal(ChangeOperation op, EventHandlerClass handlerClass, EventTarget* target)
 {
-    bool hadHandlers = m_targets[handlerClass].size();
-    bool targetSetChanged = updateEventHandlerTargets(op, handlerClass, target);
-    bool hasHandlers = m_targets[handlerClass].size();
+    bool hadHandlers = hasEventHandlers(handlerClass);
+    updateEventHandlerTargets(op, handlerClass, target);
+    bool hasHandlers = hasEventHandlers(handlerClass);
 
-    if (hadHandlers != hasHandlers)
+    if (hadHandlers != hasHandlers) {
         notifyHasHandlersChanged(handlerClass, hasHandlers);
-
-    if (targetSetChanged)
-        notifyDidAddOrRemoveEventHandlerTarget(handlerClass);
+    }
+    checkConsistency();
 }
 
 void EventHandlerRegistry::updateEventHandlerOfType(ChangeOperation op, const AtomicString& eventType, EventTarget* target)
@@ -125,41 +119,38 @@
 
 void EventHandlerRegistry::didMoveIntoFrameHost(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;
-        for (unsigned count = target.getEventListeners(eventTypes[i]).size(); count > 0; --count)
-            didAddEventHandler(target, handlerClass);
-    }
+    updateAllEventHandlers(Add, target);
 }
 
 void EventHandlerRegistry::didMoveOutOfFrameHost(EventTarget& target)
 {
-    didRemoveAllEventHandlers(target);
+    updateAllEventHandlers(RemoveAll, target);
 }
 
-void EventHandlerRegistry::didMoveBetweenFrameHosts(EventTarget& target, FrameHost* oldFrameHost, FrameHost* newFrameHost)
+void EventHandlerRegistry::didRemoveAllEventHandlers(EventTarget& target)
 {
-    ASSERT(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);
+        updateEventHandlerInternal(RemoveAll, handlerClass, &target);
     }
 }
 
-void EventHandlerRegistry::didRemoveAllEventHandlers(EventTarget& target)
+void EventHandlerRegistry::updateAllEventHandlers(ChangeOperation op, EventTarget& target)
 {
-    for (size_t i = 0; i < EventHandlerClassCount; ++i) {
-        EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
-        updateEventHandlerInternal(RemoveAll, handlerClass, &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);
     }
 }
 
@@ -176,9 +167,6 @@
         if (scrollingCoordinator)
             scrollingCoordinator->updateHaveWheelEventHandlers();
         break;
-    case TouchEvent:
-        m_frameHost.chrome().client().needTouchEvents(hasActiveHandlers);
-        break;
 #if ASSERT_ENABLED
     case EventsForTesting:
         break;
@@ -189,13 +177,6 @@
     }
 }
 
-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);