Fix LinkHighlight to position correctly w.r.t. squashed layers.

Source/web/LinkHighlight.cpp

 /*
  * Copyright (C) 2012 Google 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
@@ skipping 88 matching lines @@
 WebLayer* LinkHighlight::clipLayer()
 {
     return m_clipLayer.get();
 }
 
 void LinkHighlight::releaseResources()
 {
     m_node.clear();
 }
 
-RenderLayer* LinkHighlight::computeEnclosingCompositingLayer()
+void LinkHighlight::attachLinkHighlightToCompositingLayer(const RenderLayerModelObject* paintInvalidationContainer)
 {
-    if (!m_node || !m_node->renderer())
-        return 0;
-
-    // Find the nearest enclosing composited layer and attach to it. We may need to cross frame boundaries
-    // to find a suitable layer.
-    RenderObject* renderer = m_node->renderer();
-    RenderLayer* renderLayer;
-    do {
-        renderLayer = renderer->enclosingLayer()->enclosingLayerForPaintInvalidation();
-        if (!renderLayer) {
-            renderer = renderer->frame()->ownerRenderer();
-            if (!renderer)
-                return 0;
-        }
-    } while (!renderLayer);
-
-    ASSERT(renderLayer->compositingState() != NotComposited);
-
-    GraphicsLayer* newGraphicsLayer = renderLayer->graphicsLayerBacking();
-    if (!newGraphicsLayer->drawsContent()) {
-        newGraphicsLayer = renderLayer->graphicsLayerBackingForScrolling();
-    }
+    GraphicsLayer* newGraphicsLayer = paintInvalidationContainer->layer()->graphicsLayerBacking();

[trchen, 2014/10/29 23:57:30]

I think we need to do a null check here. Multicol renderers redirect
invalidation to the RenderFlowThread, which may not be composited. (please
correct me if I'm wrong)

[chrishtr, 2014/10/30 00:01:17]

RenderObject::containerForPaintInvalidation should never return 0, so the
paintInvalidationContainer is never 0. That's the null check you meant right?

Also, there is always a graphics layer backing since compositing is always on.

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

[trchen, 2014/10/30 00:08:58]

No I meant newGraphicsLayer may be null.
I was worrying about this line:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
I tried to prove that parentRenderFlowThread will always have a backing but
didn't have a conclusion. I don't know the code well enough to make a
counterexample either. Sorry. :(

[chrishtr, 2014/10/30 00:21:59]

Oh, yuck. Thanks for pointing that out. Fixed.

+    if (!newGraphicsLayer->drawsContent())
+        newGraphicsLayer = paintInvalidationContainer->layer()->graphicsLayerBackingForScrolling();
 
     m_clipLayer->setTransform(SkMatrix44(SkMatrix44::kIdentity_Constructor));
 
     if (m_currentGraphicsLayer != newGraphicsLayer) {
         if (m_currentGraphicsLayer)
             clearGraphicsLayerLinkHighlightPointer();
 
         m_currentGraphicsLayer = newGraphicsLayer;
         m_currentGraphicsLayer->addLinkHighlight(this);
     }
-
-    return renderLayer;
 }
 
-static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, RenderObject* compositedRenderer, FloatQuad& compositedSpaceQuad)
+static void convertTargetSpaceQuadToCompositedLayer(const FloatQuad& targetSpaceQuad, RenderObject* targetRenderer, const RenderLayerModelObject* paintInvalidationContainer, FloatQuad& compositedSpaceQuad)
 {
     ASSERT(targetRenderer);
-    ASSERT(compositedRenderer);
-
+    ASSERT(paintInvalidationContainer);
     for (unsigned i = 0; i < 4; ++i) {
         IntPoint point;
         switch (i) {
         case 0: point = roundedIntPoint(targetSpaceQuad.p1()); break;
         case 1: point = roundedIntPoint(targetSpaceQuad.p2()); break;
         case 2: point = roundedIntPoint(targetSpaceQuad.p3()); break;
         case 3: point = roundedIntPoint(targetSpaceQuad.p4()); break;
         }
 
+        // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
         point = targetRenderer->frame()->view()->contentsToWindow(point);
-        point = compositedRenderer->frame()->view()->windowToContents(point);
-        FloatPoint floatPoint = compositedRenderer->absoluteToLocal(point, UseTransforms);
+        point = paintInvalidationContainer->frame()->view()->windowToContents(point);
+        FloatPoint floatPoint = paintInvalidationContainer->absoluteToLocal(point, UseTransforms);
+        RenderLayer::mapPointToPaintBackingCoordinates(paintInvalidationContainer, floatPoint);
 
         switch (i) {
         case 0: compositedSpaceQuad.setP1(floatPoint); break;
         case 1: compositedSpaceQuad.setP2(floatPoint); break;
         case 2: compositedSpaceQuad.setP3(floatPoint); break;
         case 3: compositedSpaceQuad.setP4(floatPoint); break;
         }
     }
 }
 
@@ skipping 16 matching lines @@
 
     // For inline elements, absoluteQuads will return a line box based on the line-height
     // and font metrics, which is technically incorrect as replaced elements like images
     // should use their intristic height and expand the linebox  as needed. To get an
     // appropriately sized highlight we descend into the children and have them add their
     // boxes.
     if (renderer->isRenderInline()) {
         for (Node* child = NodeRenderingTraversal::firstChild(&node); child; child = NodeRenderingTraversal::nextSibling(child))
             computeQuads(*child, outQuads);
     } else {
+        // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
         renderer->absoluteQuads(outQuads);
     }
 }
 
-bool LinkHighlight::computeHighlightLayerPathAndPosition(RenderLayer* compositingLayer)
+bool LinkHighlight::computeHighlightLayerPathAndPosition(const RenderLayerModelObject* paintInvalidationContainer)
 {
     if (!m_node || !m_node->renderer() || !m_currentGraphicsLayer)
         return false;
-
-    ASSERT(compositingLayer);
+    ASSERT(paintInvalidationContainer);
 
     // Get quads for node in absolute coordinates.
     Vector<FloatQuad> quads;
     computeQuads(*m_node, quads);
     ASSERT(quads.size());
-
-    // Adjust for offset between target graphics layer and the node's renderer.
-    FloatPoint positionAdjust = IntPoint(m_currentGraphicsLayer->offsetFromRenderer());
-
     Path newPath;
     for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
         FloatQuad absoluteQuad = quads[quadIndex];
-        absoluteQuad.move(-positionAdjust.x(), -positionAdjust.y());
 
         // Transform node quads in target absolute coords to local coordinates in the compositor layer.
         FloatQuad transformedQuad;
-        convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), compositingLayer->renderer(), transformedQuad);
+        convertTargetSpaceQuadToCompositedLayer(absoluteQuad, m_node->renderer(), paintInvalidationContainer, transformedQuad);
 
         // FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
         // we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
         // links: these should ideally be merged into a single rect before creating the path, but that's
         // another CL.
         if (quads.size() == 1 && transformedQuad.isRectilinear()
             && !m_owningWebViewImpl->settingsImpl()->mockGestureTapHighlightsEnabled()) {
             FloatSize rectRoundingRadii(3, 3);
             newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
         } else
@@ skipping 87 matching lines @@
     releaseResources();
 }
 
 void LinkHighlight::updateGeometry()
 {
     // To avoid unnecessary updates (e.g. other entities have requested animations from our WebViewImpl),
     // only proceed if we actually requested an update.
     if (!m_geometryNeedsUpdate)
         return;
 
+    if (!m_node || !m_node->renderer())
+        return;
+
     m_geometryNeedsUpdate = false;
-
-    RenderLayer* compositingLayer = computeEnclosingCompositingLayer();
-    if (compositingLayer && computeHighlightLayerPathAndPosition(compositingLayer)) {
+    const RenderLayerModelObject* paintInvalidationContainer = m_node->renderer()->containerForPaintInvalidation();
+    attachLinkHighlightToCompositingLayer(paintInvalidationContainer);
+    if (paintInvalidationContainer && computeHighlightLayerPathAndPosition(paintInvalidationContainer)) {
         // We only need to invalidate the layer if the highlight size has changed, otherwise
         // we can just re-position the layer without needing to repaint.
         m_contentLayer->layer()->invalidate();
 
         if (m_currentGraphicsLayer)
             m_currentGraphicsLayer->addRepaintRect(FloatRect(layer()->position().x, layer()->position().y, layer()->bounds().width, layer()->bounds().height));
     } else if (!m_node || !m_node->renderer()) {
         clearGraphicsLayerLinkHighlightPointer();
         releaseResources();
     }
@@ skipping 10 matching lines @@
     // Make sure we update geometry on the next callback from WebViewImpl::layout().
     m_geometryNeedsUpdate = true;
 }
 
 WebLayer* LinkHighlight::layer()
 {
     return clipLayer();
 }
 
 } // namespace blink