Get rid of old flow thread comments and asserts 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 1248 matching lines @@
 }
 
 // Returns the layer reached on the walk up towards the ancestor.
 static inline const DeprecatedPaintLayer* accumulateOffsetTowardsAncestor(const DeprecatedPaintLayer* layer, const DeprecatedPaintLayer* ancestorLayer, LayoutPoint& location)
 {
     ASSERT(ancestorLayer != layer);
 
     const LayoutBoxModelObject* layoutObject = layer->layoutObject();
     EPosition position = layoutObject->style()->position();
 
-    // FIXME: Positioning of out-of-flow(fixed, absolute) elements collected in a LayoutFlowThread

[mstensho (USE GERRIT), 2015/06/22 19:56:44]

Comment from the early development stages in WebKit. Addressed in Blink some
long time ago, with DeprecatedPaintLayer::visualOffsetFromAncestor() et al.

-    // may need to be revisited in a future patch.
-    // If the fixed layoutObject is inside a LayoutFlowThread, we should not compute location using localToAbsolute,

[mstensho (USE GERRIT), 2015/06/22 19:56:44]

This is a comment that survived the https://codereview.chromium.org/616453002
cleanup, but shouldn't have. There used to be a type of flow threads that acted
as containers for fixed positioned descendants (something to do with CSS
regions), but this is long gone.

-    // since localToAbsolute maps the coordinates from flow thread to column set coordinates and column sets can be
-    // positioned in a completely different place in the viewport (LayoutView).
     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;
     }
 
-    // For the fixed positioned elements inside a layout flow thread, we should also skip the code path below

[mstensho (USE GERRIT), 2015/06/22 19:56:44]

Leftovers from https://codereview.chromium.org/616453002 , again.

-    // Otherwise, for the case of ancestorLayer == rootLayer and fixed positioned element child of a transformed
-    // element in layout flow thread, we will hit the fixed positioned container before hitting the ancestor layer.
     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;
@@ skipping 30 matching lines @@
         }
         return foundAncestor ? ancestorLayer : fixedPositionContainerLayer;
     }
 
     DeprecatedPaintLayer* parentLayer;
     if (position == AbsolutePosition) {
         // Do what enclosingPositionedAncestor() does, but check for ancestorLayer along the way.
         parentLayer = layer->parent();
         bool foundAncestorFirst = false;
         while (parentLayer) {
-            // LayoutFlowThread is a positioned container, child of LayoutView, positioned at (0,0).

[mstensho (USE GERRIT), 2015/06/22 19:56:44]

CSS regions stuff. Those flow threads used to be direct children of LayoutView,
and be a containing block for fixed positioned descendants.

-            // This implies that, for out-of-flow positioned elements inside a LayoutFlowThread,
-            // we are bailing out before reaching root layer.
             if (parentLayer->isPositionedContainer())
                 break;
 
             if (parentLayer == ancestorLayer) {
                 foundAncestorFirst = true;
                 break;
             }
 
             parentLayer = parentLayer->parent();
         }
 
-        // We should not reach LayoutView layer past the LayoutFlowThread layer for any

[mstensho (USE GERRIT), 2015/06/22 19:56:44]

Nothing incorrect in this assertion as such, but it just feels like a strange
place to suddenly start worrying about flow threads. Another relic from the CSS
regions days.

-        // children of the LayoutFlowThread.
-        ASSERT(!layoutObject->flowThreadContainingBlock() || parentLayer != layoutObject->view()->layer());
-
         if (foundAncestorFirst) {
             // Found ancestorLayer before the abs. positioned container, so compute offset of both relative
             // to enclosingPositionedAncestor and subtract.
             DeprecatedPaintLayer* positionedAncestor = parentLayer->enclosingPositionedAncestor();
 
             LayoutPoint thisCoords;
             layer->convertToLayerCoords(positionedAncestor, thisCoords);
 
             LayoutPoint ancestorCoords;
             ancestorLayer->convertToLayerCoords(positionedAncestor, ancestorCoords);
@@ skipping 1392 matching lines @@
 
 void showLayerTree(const blink::LayoutObject* layoutObject)
 {
     if (!layoutObject) {
         fprintf(stderr, "Cannot showLayerTree. Root is (nil)\n");
         return;
     }
     showLayerTree(layoutObject->enclosingLayer());
 }
 #endif