Apply offset from the correct graphics layer; simplify code for link highlights.

third_party/WebKit/Source/web/LinkHighlightImpl.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 139 matching lines @@
 
   if (m_currentGraphicsLayer != newGraphicsLayer) {
     if (m_currentGraphicsLayer)
       clearGraphicsLayerLinkHighlightPointer();
 
     m_currentGraphicsLayer = newGraphicsLayer;
     m_currentGraphicsLayer->addLinkHighlight(this);
   }
 }
 
-static void convertTargetSpaceQuadToCompositedLayer(
-    const FloatQuad& targetSpaceQuad,
-    LayoutObject* targetLayoutObject,
-    const LayoutBoxModelObject& paintInvalidationContainer,
-    FloatQuad& compositedSpaceQuad) {
-  DCHECK(targetLayoutObject);
-  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 = targetLayoutObject->frame()->view()->contentsToRootFrame(point);
-    point =
-        paintInvalidationContainer.frame()->view()->rootFrameToContents(point);
-    FloatPoint floatPoint =
-        paintInvalidationContainer.absoluteToLocal(point, UseTransforms);
-    PaintLayer::mapPointInPaintInvalidationContainerToBacking(
-        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;
-    }
-  }
-}
-
 static void addQuadToPath(const FloatQuad& quad, Path& path) {
   // FIXME: Make this create rounded quad-paths, just like the axis-aligned
   // case.
   path.moveTo(quad.p1());
   path.addLineTo(quad.p2());
   path.addLineTo(quad.p3());
   path.addLineTo(quad.p4());
   path.closeSubpath();
 }
 
 void LinkHighlightImpl::computeQuads(const Node& node,
                                      Vector<FloatQuad>& outQuads) const {
   if (!node.layoutObject())
     return;
 
   LayoutObject* layoutObject = node.layoutObject();
 
   // 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 (layoutObject->isLayoutInline()) {
     for (Node* child = LayoutTreeBuilderTraversal::firstChild(node); child;
          child = LayoutTreeBuilderTraversal::nextSibling(*child))
       computeQuads(*child, outQuads);
   } else {
     // FIXME: this does not need to be absolute, just in the paint invalidation
     // container's space.
-    layoutObject->absoluteQuads(outQuads);
+    layoutObject->absoluteQuads(outQuads, TraverseDocumentBoundaries);
   }
 }
 
 bool LinkHighlightImpl::computeHighlightLayerPathAndPosition(
     const LayoutBoxModelObject& paintInvalidationContainer) {
   if (!m_node || !m_node->layoutObject() || !m_currentGraphicsLayer)
     return false;
 
   // FIXME: This is defensive code to avoid crashes such as those described in
   // crbug.com/440887. This should be cleaned up once we fix the root cause of
@@ skipping 13 matching lines @@
 
     // Scrolling content layers have the same offset from layout object as the
     // non-scrolling layers. Thus we need to adjust for their scroll offset.
     if (m_isScrollingGraphicsLayer) {
       FloatPoint scrollPosition = paintInvalidationContainer.layer()
                                       ->getScrollableArea()
                                       ->scrollPosition();
       absoluteQuad.move(toScrollOffset(scrollPosition));
     }
 
-    // Transform node quads in target absolute coords to local coordinates in
-    // the compositor layer.
-    FloatQuad transformedQuad;
-    convertTargetSpaceQuadToCompositedLayer(
-        absoluteQuad, m_node->layoutObject(), paintInvalidationContainer,
-        transformedQuad);
+    absoluteQuad.setP1(roundedIntPoint(absoluteQuad.p1()));
+    absoluteQuad.setP2(roundedIntPoint(absoluteQuad.p2()));
+    absoluteQuad.setP3(roundedIntPoint(absoluteQuad.p3()));
+    absoluteQuad.setP4(roundedIntPoint(absoluteQuad.p4()));
+    FloatQuad transformedQuad = paintInvalidationContainer.absoluteToLocalQuad(
+        absoluteQuad, UseTransforms | TraverseDocumentBoundaries);
+    FloatPoint offsetToBacking;
+
+    // Adjust for squashing.
+    if (paintInvalidationContainer.layer()->groupedMapping()) {
+      PaintLayer::mapPointInPaintInvalidationContainerToBacking(
+          paintInvalidationContainer, offsetToBacking);
+    }
+
+    // Adjust for offset from LayoutObject.
+    offsetToBacking.move(-m_currentGraphicsLayer->offsetFromLayoutObject());
+
+    transformedQuad.move(toFloatSize(offsetToBacking));
 
     // 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);
@@ skipping 154 matching lines @@
 
 WebLayer* LinkHighlightImpl::layer() {
   return clipLayer();
 }
 
 CompositorAnimationPlayer* LinkHighlightImpl::compositorPlayer() const {
   return m_compositorPlayer.get();
 }
 
 }  // namespace blink