Unify code paths for fixed and absolutely positioned objects in accumulateOffsetTowardsAncestor().

Source/core/paint/DeprecatedPaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 1232 matching lines @@
     EPosition position = layoutObject->style()->position();
 
     if (position == FixedPosition && (!ancestorLayer || ancestorLayer == layoutObject->view()->layer())) {
         // If the fixed layer's container is the root, just add in the offset of the view. We can obtain this by calling
         // localToAbsolute() on the LayoutView.
         FloatPoint absPos = layoutObject->localToAbsolute(FloatPoint(), IsFixed);
         location += LayoutSize(absPos.x(), absPos.y());
         return ancestorLayer;
     }
 
-    if (position == FixedPosition) {
-        // For a fixed layers, we need to walk up to the root to see if there's a fixed position container
-        // (e.g. a transformed layer). It's an error to call convertToLayerCoords() across a layer with a transform,
-        // so we should always find the ancestor at or before we find the fixed position container, if
-        // the container is transformed.
-        DeprecatedPaintLayer* fixedPositionContainerLayer = 0;
-        bool foundAncestor = false;
-        for (DeprecatedPaintLayer* currLayer = layer->parent(); currLayer; currLayer = currLayer->parent()) {
-            if (currLayer == ancestorLayer)
-                foundAncestor = true;
-
-            if (isFixedPositionedContainer(currLayer)) {
-                fixedPositionContainerLayer = currLayer;
-                // A layer that has a transform-related property but not a
-                // transform still acts as a fixed-position container.
-                // Accumulating offsets across such layers is allowed.
-                if (currLayer->transform())
-                    ASSERT_UNUSED(foundAncestor, foundAncestor);
-                break;
-            }
-        }
-
-        ASSERT(fixedPositionContainerLayer); // We should have hit the LayoutView's layer at least.
-
-        if (fixedPositionContainerLayer != ancestorLayer) {
-            LayoutPoint fixedContainerCoords;
-            layer->convertToLayerCoords(fixedPositionContainerLayer, fixedContainerCoords);
-            location += fixedContainerCoords;
-
-            if (foundAncestor) {
-                LayoutPoint ancestorCoords;
-                ancestorLayer->convertToLayerCoords(fixedPositionContainerLayer, ancestorCoords);
-                location += -ancestorCoords;
-            }
-        } else {
-            // LayoutView has been handled in the first top-level 'if' block above.
-            ASSERT(ancestorLayer != layoutObject->view()->layer());
-            ASSERT(ancestorLayer->hasTransformRelatedProperty());
-
-            location += layer->location();
-        }
-        return foundAncestor ? ancestorLayer : fixedPositionContainerLayer;
-    }
-
     DeprecatedPaintLayer* parentLayer;
-    if (position == AbsolutePosition) {
+    if (position == AbsolutePosition || position == FixedPosition) {
         bool foundAncestorFirst;
         parentLayer = layer->enclosingPositionedAncestor(ancestorLayer, &foundAncestorFirst);
 
         if (foundAncestorFirst) {
-            // Found ancestorLayer before the abs. positioned container, so compute offset of both relative
-            // to the positioned ancestor and subtract.
+            // Found ancestorLayer before the container of the out-of-flow object, so compute offset
+            // of both relative to the container and subtract.
 
             LayoutPoint thisCoords;
             layer->convertToLayerCoords(parentLayer, thisCoords);
 
             LayoutPoint ancestorCoords;
             ancestorLayer->convertToLayerCoords(parentLayer, ancestorCoords);
 
             location += (thisCoords - ancestorCoords);
             return ancestorLayer;
         }
     } else if (layoutObject->isColumnSpanAll()) {
         LayoutBlock* multicolContainer = layoutObject->containingBlock();
         ASSERT(toLayoutBlockFlow(multicolContainer)->multiColumnFlowThread());
         parentLayer = multicolContainer->layer();
         ASSERT(parentLayer);
     } else {
         parentLayer = layer->parent();
     }
 
     if (!parentLayer)
-        return 0;
+        return nullptr;
 
     location += layer->location();
     return parentLayer;
 }
 
 void DeprecatedPaintLayer::convertToLayerCoords(const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location) const
 {
     if (ancestorLayer == this)
         return;
 
@@ skipping 1362 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif