Rework compositor touch hit testing

Source/core/rendering/RenderObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 16 matching lines @@
 #include "config.h"
 #include "core/rendering/RenderObject.h"
 
 #include "HTMLNames.h"
 #include "core/accessibility/AXObjectCache.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/editing/EditingBoundary.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/htmlediting.h"
 #include "core/html/HTMLElement.h"
+#include "core/html/HTMLFrameOwnerElement.h"
 #include "core/page/EventHandler.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
 #include "core/page/Page.h"
 #include "core/page/Settings.h"
 #include "core/page/animation/AnimationController.h"
 #include "core/platform/graphics/FloatQuad.h"
 #include "core/platform/graphics/GraphicsContext.h"
 #include "core/platform/graphics/transforms/TransformState.h"
 #include "core/rendering/FlowThreadController.h"
@@ skipping 585 matching lines @@
 
 RenderNamedFlowThread* RenderObject::renderNamedFlowThreadWrapper() const
 {
     RenderObject* object = const_cast<RenderObject*>(this);
     while (object && object->isAnonymousBlock() && !object->isRenderNamedFlowThread())
         object = object->parent();
 
     return object && object->isRenderNamedFlowThread() ? toRenderNamedFlowThread(object) : 0;
 }
 
+void RenderObject::enclosingCompositedLayerAndOffset(const RenderLayer** enclosingCompositedLayer, LayoutPoint& offset) const
+{
+    // Determine the new compositing layer and the offset from it.
+    RenderLayer* layer = enclosingLayer();
+    *enclosingCompositedLayer = layer->enclosingCompositingLayerForRepaint();
+
+    if (!*enclosingCompositedLayer) {
+        if (document()) {
+            if (HTMLFrameOwnerElement* ownerElement = document()->ownerElement()) {
+                if (RenderObject* parentDocRenderer = ownerElement->renderer()) {
+                    // Nearest composited layer is in another document.
+                    // TODO There must be a simpler way to achieve this!
+                    // Would it be simpler to use FrameView::contentsToWindow/windowToContents as in
+                    // convertTargetSpaceQuadToCompositedLayer in LinkHighlight.cpp?
+
+                    // First get the offset of this frame within the composited layer.
+                    parentDocRenderer->enclosingCompositedLayerAndOffset(enclosingCompositedLayer, offset);
+
+                    // Add the offset of the frame contents within the frame (i.e. border+padding).
+                    if (parentDocRenderer->isBox())
+                        offset.moveBy(toRenderBox(parentDocRenderer)->contentBoxRect().location());
+
+                    // Now add the offset of this object within our frame.
+                    TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
+                    mapLocalToContainer(view(), transformState, ApplyContainerFlip | UseTransforms);
+                    transformState.flatten();
+                    offset.moveBy(LayoutPoint(transformState.lastPlanarPoint()));
+
+                    // And subtract the scroll offset of this frame.
+                    offset -= frame()->view()->scrollOffset();
+                }
+            }
+        }
+        return;
+    }
+
+    // Self-painting layers subtract the renderer's location. Otherwise, we need to map our location to layer space.
+    if ((*enclosingCompositedLayer)->renderer() == this) {
+        offset = LayoutPoint();
+    } else {
+        TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
+        mapLocalToContainer((*enclosingCompositedLayer)->renderer(), transformState, ApplyContainerFlip | UseTransforms);
+        transformState.flatten();
+        offset = LayoutPoint(transformState.lastPlanarPoint());
+    }
+}
+
 RenderBlock* RenderObject::firstLineBlock() const
 {
     return 0;
 }
 
 static inline bool objectIsRelayoutBoundary(const RenderObject* object)
 {
     // FIXME: In future it may be possible to broaden these conditions in order to improve performance.
     if (object->isTextControl())
         return true;
@@ skipping 1608 matching lines @@
 }
 
 LayoutRect RenderObject::localCaretRect(InlineBox*, int, LayoutUnit* extraWidthToEndOfLine)
 {
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = 0;
 
     return LayoutRect();
 }
 
+void RenderObject::computeLayerHitTestRects(LayerHitTestRects& layerRects) const
+{
+    // Figure out what composited layer our container is in. Any offset (or new layer) for this
+    // renderer within it's container will be applied in addLayerHitTestRects.
+    LayoutPoint layerOffset;
+    const RenderLayer* currentCompositedLayer;
+    if (container())
+        container()->enclosingCompositedLayerAndOffset(&currentCompositedLayer, layerOffset);
+    else
+        enclosingCompositedLayerAndOffset(&currentCompositedLayer, layerOffset);
+    if (!currentCompositedLayer)
+        return;
+
+    this->addLayerHitTestRects(layerRects, currentCompositedLayer, layerOffset);
+}
+
+void RenderObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const RenderLayer* currentCompositedLayer, const LayoutPoint& layerOffset) const
+{
+    ASSERT(currentCompositedLayer);
+
+    // If it's possible for children to have rects outside our bounds, then we need to descend into the
+    // children and compute them.
+    // TODO: Any tighter guarantee on when we don't need to descend into children?

[leviw_travelin_and_unemployed, 2013/07/10 01:51:16]

I don't think there's any tighter guarantee, but good catch on the optimization
of using isRoot().

+    // TODO: Should I improve Region and use it? https://bugs.webkit.org/show_bug.cgi?id=100814
+    if (!isRoot()) {
+        for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {
+            // TODO: levi's original patch excluded curr->isText(), curr->isListMarker() and !curr->isBox(). Why?

[leviw_travelin_and_unemployed, 2013/07/10 01:51:16]

I can't recall on the latter two, but text nodes aren't event targets and should
be handled by their containing elements.

+            curr->addLayerHitTestRects(layerRects, currentCompositedLayer,  layerOffset);
+        }
+    }
+
+    // Compute the rects for this renderer only and add them to the results.
+    // TODO: We could avoid passing the offset here and instead offset each result.
+    Vector<IntRect> ownRects;
+    computeOwnHitTestRects(ownRects, layerOffset);
+
+    LayerHitTestRects::iterator iter = layerRects.find(currentCompositedLayer);
+    if (iter == layerRects.end())
+        layerRects.add(currentCompositedLayer, ownRects);
+    else
+        iter->value.append(ownRects);
+}
+
 bool RenderObject::isRooted(RenderView** view) const
 {
     const RenderObject* o = this;
     while (o->parent())
         o = o->parent();
 
     if (!o->isRenderView())
         return false;
 
     if (view)
@@ skipping 957 matching lines @@
 {
     if (object1) {
         const WebCore::RenderObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif