Rework compositor touch hit testing

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
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * 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/Node.h"
+#include "core/html/HTMLElement.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
 #include "core/page/Page.h"
 #include "core/platform/PlatformWheelEvent.h"
 #include "core/platform/ScrollAnimator.h"
 #include "core/platform/ScrollbarThemeComposite.h"
+#include "core/platform/chromium/TraceEvent.h"
 #include "core/platform/chromium/support/WebScrollbarImpl.h"
 #include "core/platform/chromium/support/WebScrollbarThemeGeometryNative.h"
 #include "core/platform/graphics/GraphicsLayer.h"
 #include "core/platform/graphics/IntRect.h"
 #include "core/platform/graphics/Region.h"
+#include "core/platform/graphics/transforms/TransformState.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/RenderLayerBacking.h"
 #include "core/rendering/RenderLayerCompositor.h"
 #include "core/rendering/RenderView.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebLayerPositionConstraint.h"
 #include "public/platform/WebScrollbarLayer.h"
 #include "public/platform/WebScrollbarThemeGeometry.h"
 #include "public/platform/WebScrollbarThemePainter.h"
@@ skipping 46 matching lines @@
         WebVector<WebRect> webRects(rects.size());
         for (size_t i = 0; i < rects.size(); ++i)
             webRects[i] = rects[i];
         scrollLayer->setNonFastScrollableRegion(webRects);
     }
 }
 
 void ScrollingCoordinator::frameViewLayoutUpdated(FrameView* frameView)
 {
     ASSERT(m_page);
+    if (!RuntimeEnabledFeatures::touchEnabled())
+        return;
+
+    TRACE_EVENT0("input", "ScrollingCoordinator::frameViewLayoutUpdated");
 
     // Compute the region of the page that we can't handle scroll gestures on impl thread:
     // This currently includes:
     // 1. All scrollable areas, such as subframes, overflow divs and list boxes, whose composited
     // scrolling are not enabled. We need to do this even if the frame view whose layout was updated
     // is not the main frame.
     // 2. Resize control areas, e.g. the small rect at the right bottom of div/textarea/iframe when
     // CSS property "resize" is enabled.
     // 3. Plugin areas.
     Region shouldHandleScrollGestureOnMainThreadRegion = computeShouldHandleScrollGestureOnMainThreadRegion(m_page->mainFrame(), IntPoint());
     setShouldHandleScrollGestureOnMainThreadRegion(shouldHandleScrollGestureOnMainThreadRegion);
-    Vector<IntRect> touchEventTargetRects;
-    computeAbsoluteTouchEventTargetRects(m_page->mainFrame()->document(), touchEventTargetRects);
+    LayerHitTestRects touchEventTargetRects;
+    computeTouchEventTargetRects(touchEventTargetRects);
     setTouchEventTargetRects(touchEventTargetRects);
     if (WebLayer* scrollLayer = scrollingWebLayerForScrollableArea(frameView))
         scrollLayer->setBounds(frameView->contentsSize());
 }
 
 void ScrollingCoordinator::setLayerIsContainerForFixedPositionLayers(GraphicsLayer* layer, bool enable)
 {
     if (WebLayer* scrollableLayer = scrollingWebLayerForGraphicsLayer(layer))
         scrollableLayer->setIsContainerForFixedPositionLayers(enable);
 }
@@ skipping 158 matching lines @@
     }
     if (WebScrollbarLayer* scrollbarLayer = getWebScrollbarLayer(scrollableArea, VerticalScrollbar)) {
         GraphicsLayer* verticalScrollbarLayer = verticalScrollbarLayerForScrollableArea(scrollableArea);
         if (verticalScrollbarLayer)
             setupScrollbarLayer(verticalScrollbarLayer, scrollbarLayer, webLayer);
     }
 
     return !!webLayer;
 }
 
-void ScrollingCoordinator::setTouchEventTargetRects(const Vector<IntRect>& absoluteHitTestRects)
+static void convertLayerRectsToEnclosingCompositedLayer(const LayerHitTestRects& layerRects, LayerHitTestRects& compositorRects)
 {
-    if (WebLayer* scrollLayer = scrollingWebLayerForScrollableArea(m_page->mainFrame()->view())) {
-        WebVector<WebRect> webRects(absoluteHitTestRects.size());
-        for (size_t i = 0; i < absoluteHitTestRects.size(); ++i)
-            webRects[i] = absoluteHitTestRects[i];
-        scrollLayer->setTouchEventHandlerRegion(webRects);
+    // We have a set of rects per RenderLayer, we need to map them to their bounding boxes in their
+    // enclosing composited layer.
+    for (LayerHitTestRects::const_iterator layerIter = layerRects.begin(); layerIter != layerRects.end(); ++layerIter) {
+        // Find the enclosing composited layer when it's in another document (for non-composited iframes).
+        RenderLayer* compositedLayer = 0;
+        for (const RenderLayer* layer = layerIter->key; !compositedLayer;) {
+            compositedLayer = layer->enclosingCompositingLayerForRepaint();
+            if (!compositedLayer) {
+                RenderObject* owner = layer->renderer()->frame()->ownerRenderer();
+                if (!owner)
+                    break;
+                layer = owner->enclosingLayer();
+            }
+        }
+        // This page may not have compositing enabled at all.

[leviw_travelin_and_unemployed, 2013/07/18 20:23:03]

So I get that, but then we should return, not continue, right?

+        if (!compositedLayer)
+            continue;
+
+        LayerHitTestRects::iterator compIter = compositorRects.find(compositedLayer);
+        if (compIter == compositorRects.end())
+            compIter = compositorRects.add(compositedLayer, Vector<IntRect>()).iterator;
+
+        // Transform each rect to the co-ordinate space of it's enclosing composited layer.
+        // Ideally we'd compute a transformation matrix once and re-use it for each rect, but
+        // there doesn't appear to be any easy way to do it (mapLocalToContainer will flatten
+        // the TransformState, so we can't use setQuad/mappedQuad over and over again). Perhaps
+        // RenderGeometryMap?
+        for (size_t i = 0; i < layerIter->value.size(); ++i) {
+            FloatQuad localQuad(layerIter->value[i]);
+            TransformState transformState(TransformState::ApplyTransformDirection, localQuad);
+            MapCoordinatesFlags flags = ApplyContainerFlip | UseTransforms | TraverseDocumentBoundaries;
+            layerIter->key->renderer()->mapLocalToContainer(compositedLayer->renderer(), transformState, flags);
+            transformState.flatten();
+            IntRect compositorRect = enclosingIntRect(transformState.lastPlanarQuad().boundingBox());
+            compIter->value.append(compositorRect);
+        }
+    }
+}
+
+void ScrollingCoordinator::setTouchEventTargetRects(const LayerHitTestRects& layerRects)
+{
+    TRACE_EVENT0("input", "ScrollingCoordinator::setTouchEventTargetRects");
+
+    LayerHitTestRects compositorRects;
+    convertLayerRectsToEnclosingCompositedLayer(layerRects, compositorRects);
+
+    // Inform any observers (i.e. for testing) of these new rects.
+    HashSet<TouchEventTargetRectsObserver*>::iterator stop = m_touchEventTargetRectsObservers.end();
+    for (HashSet<TouchEventTargetRectsObserver*>::iterator it = m_touchEventTargetRectsObservers.begin(); it != stop; ++it)
+        (*it)->touchEventTargetRectsChanged(compositorRects);
+
+    // Note that ideally we'd clear the touch event handler region on all layers first,
+    // in case there are others that no longer have any handlers. But it's unlikely to
+    // matter much in practice (just makes us more conservative).
+    for (LayerHitTestRects::const_iterator iter = compositorRects.begin(); iter != compositorRects.end(); ++iter) {
+        WebVector<WebRect> webRects(iter->value.size());
+        for (size_t i = 0; i < iter->value.size(); ++i)
+            webRects[i] = iter->value[i];
+        RenderLayerBacking* backing = iter->key->backing();
+        // If the layer is using composited scrolling, then it's the contents that these
+        // rects apply to.
+        GraphicsLayer* graphicsLayer = backing->scrollingContentsLayer();
+        if (!graphicsLayer)
+            graphicsLayer = backing->graphicsLayer();
+        graphicsLayer->platformLayer()->setTouchEventHandlerRegion(webRects);
     }
 }
 
 void ScrollingCoordinator::touchEventTargetRectsDidChange(const Document*)
 {
-    // The rects are always evaluated and used in the main frame coordinates.
-    FrameView* frameView = m_page->mainFrame()->view();
-    Document* document = m_page->mainFrame()->document();
+    if (!RuntimeEnabledFeatures::touchEnabled())
+        return;
 
     // Wait until after layout to update.
-    if (frameView->needsLayout() || !document)
+    if (m_page->mainFrame()->view()->needsLayout())
         return;
 
-    Vector<IntRect> touchEventTargetRects;
-    computeAbsoluteTouchEventTargetRects(document, touchEventTargetRects);
+    TRACE_EVENT0("input", "ScrollingCoordinator::touchEventTargetRectsDidChange");
+
+    LayerHitTestRects touchEventTargetRects;
+    computeTouchEventTargetRects(touchEventTargetRects);
     setTouchEventTargetRects(touchEventTargetRects);
 }
 
 void ScrollingCoordinator::setWheelEventHandlerCount(unsigned count)
 {
     if (WebLayer* scrollLayer = scrollingWebLayerForScrollableArea(m_page->mainFrame()->view()))
         scrollLayer->setHaveWheelEventHandlers(count > 0);
 }
 
 void ScrollingCoordinator::recomputeWheelEventHandlerCountForFrameView(FrameView* frameView)
@@ skipping 25 matching lines @@
 
     // We currently only support composited mode.
     RenderView* renderView = m_page->mainFrame()->contentRenderer();
     if (!renderView)
         return false;
     return renderView->usesCompositing();
 }
 
 Region ScrollingCoordinator::computeShouldHandleScrollGestureOnMainThreadRegion(const Frame* frame, const IntPoint& frameLocation) const
 {
+    TRACE_EVENT0("input", "ScrollingCoordinator::computeShouldHandleScrollGestureOnMainThreadRegion");
     Region shouldHandleScrollGestureOnMainThreadRegion;
     FrameView* frameView = frame->view();
     if (!frameView)
         return shouldHandleScrollGestureOnMainThreadRegion;
 
     IntPoint offset = frameLocation;
     offset.moveBy(frameView->frameRect().location());
 
     if (const FrameView::ScrollableAreaSet* scrollableAreas = frameView->scrollableAreas()) {
         for (FrameView::ScrollableAreaSet::const_iterator it = scrollableAreas->begin(), end = scrollableAreas->end(); it != end; ++it) {
@@ skipping 32 matching lines @@
         }
     }
 
     FrameTree* tree = frame->tree();
     for (Frame* subFrame = tree->firstChild(); subFrame; subFrame = subFrame->tree()->nextSibling())
         shouldHandleScrollGestureOnMainThreadRegion.unite(computeShouldHandleScrollGestureOnMainThreadRegion(subFrame, offset));
 
     return shouldHandleScrollGestureOnMainThreadRegion;
 }
 
-static void accumulateRendererTouchEventTargetRects(Vector<IntRect>& rects, const RenderObject* renderer, const IntRect& parentRect = IntRect())
+void ScrollingCoordinator::addTouchEventTargetRectsObserver(TouchEventTargetRectsObserver* observer)
 {
-    IntRect adjustedParentRect = parentRect;
-    if (parentRect.isEmpty() || renderer->isFloating() || renderer->isPositioned() || renderer->hasTransform()) {
-        // FIXME: This method is O(N^2) as it walks the tree to the root for every renderer. RenderGeometryMap would fix this.
-        IntRect r = enclosingIntRect(renderer->clippedOverflowRectForRepaint(0));
-        if (!r.isEmpty()) {
-            // Convert to the top-level view's coordinates.
-            ASSERT(renderer->document()->view());
-            r = renderer->document()->view()->convertToRootView(r);
-
-            if (!parentRect.contains(r)) {
-                rects.append(r);
-                adjustedParentRect = r;
-            }
-        }
-    }
-
-    for (RenderObject* child = renderer->firstChild(); child; child = child->nextSibling())
-        accumulateRendererTouchEventTargetRects(rects, child, adjustedParentRect);
+    m_touchEventTargetRectsObservers.add(observer);
 }
 
-static void accumulateDocumentEventTargetRects(Vector<IntRect>& rects, const Document* document)
+void ScrollingCoordinator::removeTouchEventTargetRectsObserver(TouchEventTargetRectsObserver* observer)
+{
+    m_touchEventTargetRectsObservers.remove(observer);
+}
+
+static void accumulateDocumentTouchEventTargetRects(LayerHitTestRects& rects, const Document* document)
 {
     ASSERT(document);
     if (!document->touchEventTargets())
         return;
 
     const TouchEventTargetSet* targets = document->touchEventTargets();
+
+    // If there's a handler on the 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) {
-        const Node* touchTarget = iter->key;
-        if (!touchTarget->inDocument())
-            continue;
-
-        if (touchTarget == document) {
-            if (RenderView* view = document->renderView()) {
-                IntRect r;
-                if (touchTarget == document->topDocument())
-                    r = view->documentRect();
-                else
-                    r = enclosingIntRect(view->clippedOverflowRectForRepaint(0));
-
-                if (!r.isEmpty()) {
-                    ASSERT(view->document()->view());
-                    r = view->document()->view()->convertToRootView(r);
-                    rects.append(r);
-                }
+        Node* target = iter->key;
+        if (target == document || target == document->documentElement() || target == document->body()) {
+            if (RenderObject* renderer = document->renderer()) {
+                renderer->computeLayerHitTestRects(rects);
             }
             return;
         }
+    }
 
-        if (touchTarget->isDocumentNode() && touchTarget != document) {
-            accumulateDocumentEventTargetRects(rects, toDocument(touchTarget));
+    for (TouchEventTargetSet::const_iterator iter = targets->begin(); iter != targets->end(); ++iter) {
+        const Node* target = iter->key;
+        if (!target->inDocument())
             continue;
+
+        if (target->isDocumentNode()) {
+            ASSERT(target != document);
+            accumulateDocumentTouchEventTargetRects(rects, toDocument(target));
+        } else if (RenderObject* renderer = target->renderer()) {
+            renderer->computeLayerHitTestRects(rects);
         }
+    }
 
-        if (RenderObject* renderer = touchTarget->renderer())
-            accumulateRendererTouchEventTargetRects(rects, renderer);
-    }
 }
 
-void ScrollingCoordinator::computeAbsoluteTouchEventTargetRects(const Document* document, Vector<IntRect>& rects)
+void ScrollingCoordinator::computeTouchEventTargetRects(LayerHitTestRects& rects)
 {
-    ASSERT(document);
-    if (!document->view())
+    TRACE_EVENT0("input", "ScrollingCoordinator::computeTouchEventTargetRects");
+
+    Document* document = m_page->mainFrame()->document();
+    if (!document || !document->view())
         return;
 
-    // FIXME: These rects won't be properly updated if the renderers are in a sub-tree that scrolls.
-    accumulateDocumentEventTargetRects(rects, document);
+    accumulateDocumentTouchEventTargetRects(rects, document);
 }
 
 unsigned ScrollingCoordinator::computeCurrentWheelEventHandlerCount()
 {
     unsigned wheelEventHandlerCount = 0;
 
     for (Frame* frame = m_page->mainFrame(); frame; frame = frame->tree()->traverseNext()) {
         if (frame->document())
             wheelEventHandlerCount += frame->document()->wheelEventHandlerCount();
     }
@@ skipping 151 matching lines @@
         stringBuilder.resize(stringBuilder.length() - 2);
     return stringBuilder.toString();
 }
 
 String ScrollingCoordinator::mainThreadScrollingReasonsAsText() const
 {
     return mainThreadScrollingReasonsAsText(mainThreadScrollingReasons());
 }
 
 } // namespace WebCore