Add EventHandlerRegistry

Source/core/page/scrolling/ScrollingCoordinator.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 11 matching lines @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/page/scrolling/ScrollingCoordinator.h"
 
 #include "RuntimeEnabledFeatures.h"
 #include "core/dom/Document.h"
+#include "core/dom/EventHandlerRegistry.h"
 #include "core/dom/FullscreenElementStack.h"
 #include "core/dom/Node.h"
-#include "core/dom/WheelController.h"
-#include "core/html/HTMLElement.h"
+#include "core/frame/DOMWindow.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
+#include "core/html/HTMLElement.h"
 #include "core/page/Page.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/RenderGeometryMap.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/compositing/CompositedLayerMapping.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
 #include "platform/TraceEvent.h"
 #include "platform/exported/WebScrollbarImpl.h"
 #include "platform/exported/WebScrollbarThemeGeometryNative.h"
 #include "platform/geometry/Region.h"
@@ skipping 575 matching lines @@
 {
     m_layersWithTouchRects.remove(layer);
 }
 
 void ScrollingCoordinator::setWheelEventHandlerCount(unsigned count)
 {
     if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling()))
         scrollLayer->setHaveWheelEventHandlers(count > 0);
 }
 
-void ScrollingCoordinator::recomputeWheelEventHandlerCountForFrameView(FrameView*)
+void ScrollingCoordinator::setScrollEventHandlerCount(unsigned count)
 {
-    setWheelEventHandlerCount(computeCurrentWheelEventHandlerCount());
+    if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling()))
+        scrollLayer->setHaveScrollEventHandlers(count > 0);
+}
+
+void ScrollingCoordinator::updateWheelEventHandlerCountForFrameView(FrameView*)
+{
+    LocalFrame* frame = m_page->mainFrame();
+    unsigned count = EventHandlerRegistry::from(*frame->document())->eventHandlerCount(EventHandlerRegistry::WheelEvent);
+    setWheelEventHandlerCount(count);
+}
+
+void ScrollingCoordinator::updateScrollEventHandlerCountForFrameView(FrameView*)
+{
+    LocalFrame* frame = m_page->mainFrame();
+    unsigned count = EventHandlerRegistry::from(*frame->document())->eventHandlerCount(EventHandlerRegistry::ScrollEvent);

[Rick Byers, 2014/03/27 16:43:31]

why all this work with 'counts' when this function ever seems to do with them is
check >0?  It would be simpler and faster to just have a 'bool hasWheelHandlers'
etc...

[Sami, 2014/04/02 19:58:05]

Yeah, the more I looked at this the more obvious it became that the counts are
completely unnecessary. ScrollingCoordinator now only deals with the global
presence of handlers and the only counting going on is in tests (and the bit in
LocalFrame which is going away).

+    setScrollEventHandlerCount(count);
 }
 
 void ScrollingCoordinator::setShouldUpdateScrollLayerPositionOnMainThread(MainThreadScrollingReasons reasons)
 {
     if (WebLayer* scrollLayer = toWebLayer(m_page->mainFrame()->view()->layerForScrolling())) {
         m_lastMainThreadScrollingReasons = reasons;
         scrollLayer->setShouldScrollOnMainThread(reasons);
     }
 }
 
@@ skipping 66 matching lines @@
         }
     }
 
     const FrameTree& tree = frame->tree();
     for (LocalFrame* subFrame = tree.firstChild(); subFrame; subFrame = subFrame->tree().nextSibling())
         shouldHandleScrollGestureOnMainThreadRegion.unite(computeShouldHandleScrollGestureOnMainThreadRegion(subFrame, offset));
 
     return shouldHandleScrollGestureOnMainThreadRegion;
 }
 
-static void accumulateDocumentTouchEventTargetRects(LayerHitTestRects& rects, const Document* document)
+static void accumulateDocumentTouchEventTargetRects(LayerHitTestRects& rects, Document* document)
 {
     ASSERT(document);
-    if (!document->touchEventTargets())
+    const EventTargetSet* targets = EventHandlerRegistry::from(*document)->eventHandlerTargets(EventHandlerRegistry::TouchEvent);
+    if (!targets)
         return;
 
-    const TouchEventTargetSet* targets = document->touchEventTargets();
-
-    // If there's a handler on the document, html or body element (fairly common in practice),
+    // If there's a handler on the window, document, html or body element (fairly common in practice),
     // then we can quickly mark the entire document and skip looking at any other handlers.
     // Note that technically a handler on the body doesn't cover the whole document, but it's
     // reasonable to be conservative and report the whole document anyway.
-    for (TouchEventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
-        Node* target = iter->key;
-        if (target == document || target == document->documentElement() || target == document->body()) {
+    for (EventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
+        EventTarget* target = iter->key;
+        Node* node = target->toNode();
+        if (target->toDOMWindow() || node == document || node == document->documentElement() || node == document->body()) {
             if (RenderObject* renderer = document->renderer()) {
                 renderer->computeLayerHitTestRects(rects);
             }
             return;
         }
     }
 
-    for (TouchEventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
-        const Node* target = iter->key;
-        if (!target->inDocument())
+    for (EventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
+        EventTarget* target = iter->key;
+        Node* node = target->toDOMWindow() ? target->toDOMWindow()->document() : target->toNode();

[Rick Byers, 2014/03/27 16:43:31]

Would be simpler to just combine this with the "if(node->isDocumentNode())"
check below (I.e. only get a Node object at all in the else case).

[Sami, 2014/04/02 19:58:05]

Done.

+        if (!node->inDocument())
             continue;
 
-        if (target->isDocumentNode()) {
-            ASSERT(target != document);
-            accumulateDocumentTouchEventTargetRects(rects, toDocument(target));
-        } else if (RenderObject* renderer = target->renderer()) {
+        if (node->isDocumentNode()) {
+            ASSERT(node != document);
+            accumulateDocumentTouchEventTargetRects(rects, toDocument(node));
+        } else if (RenderObject* renderer = node->renderer()) {
             // If the set also contains one of our ancestor nodes then processing
             // this node would be redundant.
             bool hasTouchEventTargetAncestor = false;
-            for (Node* ancestor = target->parentNode(); ancestor && !hasTouchEventTargetAncestor; ancestor = ancestor->parentNode()) {
+            for (Node* ancestor = node->parentNode(); ancestor && !hasTouchEventTargetAncestor; ancestor = ancestor->parentNode()) {
                 if (targets->contains(ancestor))
                     hasTouchEventTargetAncestor = true;
             }
             if (!hasTouchEventTargetAncestor) {
                 // Walk up the tree to the outermost non-composited scrollable layer.
                 RenderLayer* enclosingNonCompositedScrollLayer = 0;
                 for (RenderLayer* parent = renderer->enclosingLayer(); parent && parent->compositingState() == NotComposited; parent = parent->parent()) {
                     if (parent->scrollsOverflow())
                         enclosingNonCompositedScrollLayer = parent;
                 }
@@ skipping 18 matching lines @@
     TRACE_EVENT0("input", "ScrollingCoordinator::computeTouchEventTargetRects");
     ASSERT(touchHitTestingEnabled());
 
     Document* document = m_page->mainFrame()->document();
     if (!document || !document->view())
         return;
 
     accumulateDocumentTouchEventTargetRects(rects, document);
 }
 
-unsigned ScrollingCoordinator::computeCurrentWheelEventHandlerCount()
-{
-    unsigned wheelEventHandlerCount = 0;
-
-    for (LocalFrame* frame = m_page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
-        if (frame->document())
-            wheelEventHandlerCount += WheelController::from(*frame->document())->wheelEventHandlerCount();
-    }
-
-    return wheelEventHandlerCount;
-}
-
 void ScrollingCoordinator::frameViewWheelEventHandlerCountChanged(FrameView* frameView)
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
 
-    recomputeWheelEventHandlerCountForFrameView(frameView);
+    updateWheelEventHandlerCountForFrameView(frameView);
+}
+
+void ScrollingCoordinator::frameViewScrollEventHandlerCountChanged(FrameView* frameView)
+{
+    ASSERT(isMainThread());
+    ASSERT(m_page);
+
+    updateScrollEventHandlerCountForFrameView(frameView);
 }
 
 void ScrollingCoordinator::frameViewHasSlowRepaintObjectsDidChange(FrameView* frameView)
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
 
     if (!coordinatesScrollingForFrameView(frameView))
         return;
 
@@ skipping 31 matching lines @@
 
 void ScrollingCoordinator::frameViewRootLayerDidChange(FrameView* frameView)
 {
     ASSERT(isMainThread());
     ASSERT(m_page);
 
     if (!coordinatesScrollingForFrameView(frameView))
         return;
 
     notifyLayoutUpdated();
-    recomputeWheelEventHandlerCountForFrameView(frameView);
+    updateWheelEventHandlerCountForFrameView(frameView);
+    updateScrollEventHandlerCountForFrameView(frameView);
 }
 
 #if OS(MACOSX)
 void ScrollingCoordinator::handleWheelEventPhase(PlatformWheelEventPhase phase)
 {
     ASSERT(isMainThread());
 
     if (!m_page)
         return;
 
@@ skipping 75 matching lines @@
     bool frameIsScrollable = frameView && frameView->isScrollable();
     if (frameIsScrollable != m_wasFrameScrollable)
         return true;
 
     if (WebLayer* scrollLayer = frameView ? toWebLayer(frameView->layerForScrolling()) : 0)
         return blink::WebSize(frameView->contentsSize()) != scrollLayer->bounds();
     return false;
 }
 
 } // namespace WebCore