paintInvalidationContainerSkipped/containerSkipped => ancestorSkipped

third_party/WebKit/Source/core/layout/LayoutObject.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 863 matching lines @@
         o->m_bitfields.setPreferredLogicalWidthsDirty(true);
         if (o->style()->hasOutOfFlowPosition()) {
             // A positioned object has no effect on the min/max width of its containing block ever.
             // We can optimize this case and not go up any further.
             break;
         }
         o = container;
     }
 }
 
-LayoutObject* LayoutObject::containerForAbsolutePosition(const LayoutBoxModelObject* paintInvalidationContainer, bool* paintInvalidationContainerSkipped) const
+LayoutObject* LayoutObject::containerForAbsolutePosition(const LayoutBoxModelObject* ancestor, bool* ancestorSkipped) const
 {
     // We technically just want our containing block, but
     // we may not have one if we're part of an uninstalled
     // subtree. We'll climb as high as we can though.
     for (LayoutObject* object = parent(); object; object = object->parent()) {
         if (object->canContainAbsolutePositionObjects())
             return object;
 
-        if (paintInvalidationContainerSkipped && object == paintInvalidationContainer)
-            *paintInvalidationContainerSkipped = true;
+        if (ancestorSkipped && object == ancestor)
+            *ancestorSkipped = true;
     }
     return nullptr;
 }
 
-LayoutBlock* LayoutObject::containerForFixedPosition(const LayoutBoxModelObject* paintInvalidationContainer, bool* paintInvalidationContainerSkipped) const
+LayoutBlock* LayoutObject::containerForFixedPosition(const LayoutBoxModelObject* ancestor, bool* ancestorSkipped) const
 {
-    ASSERT(!paintInvalidationContainerSkipped || !*paintInvalidationContainerSkipped);
+    ASSERT(!ancestorSkipped || !*ancestorSkipped);
     ASSERT(!isText());
 
-    LayoutObject* ancestor = parent();
-    for (; ancestor && !ancestor->canContainFixedPositionObjects(); ancestor = ancestor->parent()) {
-        if (paintInvalidationContainerSkipped && ancestor == paintInvalidationContainer)
-            *paintInvalidationContainerSkipped = true;
+    LayoutObject* object = parent();
+    for (; object && !object->canContainFixedPositionObjects(); object = object->parent()) {
+        if (ancestorSkipped && object == ancestor)
+            *ancestorSkipped = true;
     }
 
-    ASSERT(!ancestor || !ancestor->isAnonymousBlock());
-    return toLayoutBlock(ancestor);
+    ASSERT(!object || !object->isAnonymousBlock());
+    return toLayoutBlock(object);
 }
 
 LayoutBlock* LayoutObject::containingBlockForAbsolutePosition() const
 {
     LayoutObject* o = containerForAbsolutePosition();
 
     // For relpositioned inlines, we return the nearest non-anonymous enclosing block. We don't try
     // to return the inline itself.  This allows us to avoid having a positioned objects
     // list in all LayoutInlines and lets us return a strongly-typed LayoutBlock* result
     // from this method.  The container() method can actually be used to obtain the
@@ skipping 1316 matching lines @@
     mapAncestorToLocal(ancestor, transformState, mode);
     transformState.flatten();
     return transformState.lastPlanarQuad();
 }
 
 void LayoutObject::mapLocalToAncestor(const LayoutBoxModelObject* ancestor, TransformState& transformState, MapCoordinatesFlags mode) const
 {
     if (ancestor == this)
         return;
 
-    bool containerSkipped;
-    const LayoutObject* o = container(ancestor, &containerSkipped);
+    bool ancestorSkipped;
+    const LayoutObject* o = container(ancestor, &ancestorSkipped);
     if (!o)
         return;
 
     if (mode & ApplyContainerFlip) {
         if (isBox()) {
             mode &= ~ApplyContainerFlip;
         } else if (o->isBox()) {
             if (o->style()->isFlippedBlocksWritingMode()) {
                 IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
                 transformState.move(toLayoutBox(o)->flipForWritingMode(LayoutPoint(centerPoint)) - centerPoint);
@@ skipping 13 matching lines @@
     // Text objects just copy their parent's computed style, so we need to ignore them.
     bool preserve3D = mode & UseTransforms && ((o->style()->preserves3D() && !o->isText()) || (style()->preserves3D() && !isText()));
     if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
         TransformationMatrix t;
         getTransformFromContainer(o, containerOffset, t);
         transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
     } else {
         transformState.move(containerOffset.width(), containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
     }
 
-    if (containerSkipped) {
+    if (ancestorSkipped) {
         // There can't be a transform between |ancestor| and |o|, because transforms create
         // containers, so it should be safe to just subtract the delta between the ancestor and |o|.
         LayoutSize containerOffset = ancestor->offsetFromAncestorContainer(o);
         transformState.move(-containerOffset.width(), -containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
         return;
     }
 
     o->mapLocalToAncestor(ancestor, transformState, mode);
 }
 
 const LayoutObject* LayoutObject::pushMappingToContainer(const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap) const
 {
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 void LayoutObject::mapAncestorToLocal(const LayoutBoxModelObject* ancestor, TransformState& transformState, MapCoordinatesFlags mode) const
 {
     if (this == ancestor)
         return;
 
-    bool containerSkipped;
-    LayoutObject* o = container(ancestor, &containerSkipped);
+    bool ancestorSkipped;
+    LayoutObject* o = container(ancestor, &ancestorSkipped);
     if (!o)
         return;
 
     bool applyContainerFlip = false;
     if (mode & ApplyContainerFlip) {
         if (isBox()) {
             mode &= ~ApplyContainerFlip;
         } else if (o->isBox()) {
             applyContainerFlip = o->style()->isFlippedBlocksWritingMode();
             mode &= ~ApplyContainerFlip;
         }
     }
 
-    if (!containerSkipped)
+    if (!ancestorSkipped)
         o->mapAncestorToLocal(ancestor, transformState, mode);
 
     LayoutSize containerOffset = offsetFromContainer(o);
     if (o->isLayoutFlowThread()) {
         // Descending into a flow thread. Convert to the local coordinate space, i.e. flow thread coordinates.
         LayoutPoint visualPoint = LayoutPoint(transformState.mappedPoint());
         transformState.move(visualPoint - toLayoutFlowThread(o)->visualPointToFlowThreadPoint(visualPoint));
     }
 
     bool preserve3D = mode & UseTransforms && (o->style()->preserves3D() || style()->preserves3D());
     if (mode & UseTransforms && shouldUseTransformFromContainer(o)) {
         TransformationMatrix t;
         getTransformFromContainer(o, containerOffset, t);
         transformState.applyTransform(t, preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
     } else {
         transformState.move(containerOffset.width(), containerOffset.height(), preserve3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform);
     }
 
     if (applyContainerFlip) {
         IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
         transformState.move(centerPoint - toLayoutBox(o)->flipForWritingMode(LayoutPoint(centerPoint)));
     }
 
-    if (containerSkipped) {
+    if (ancestorSkipped) {
         containerOffset = ancestor->offsetFromAncestorContainer(o);
         transformState.move(-containerOffset.width(), -containerOffset.height());
     }
 }
 
 bool LayoutObject::shouldUseTransformFromContainer(const LayoutObject* containerObject) const
 {
     // hasTransform() indicates whether the object has transform, transform-style or perspective. We just care about transform,
     // so check the layer's transform directly.
     return (hasLayer() && toLayoutBoxModelObject(this)->layer()->transform()) || (containerObject && containerObject->style()->hasPerspective());
@@ skipping 223 matching lines @@
 
     if (layoutObject->document().settings() && layoutObject->document().settings()->shouldRespectImageOrientation())
         return RespectImageOrientation;
 
     if (layoutObject->style() && layoutObject->style()->respectImageOrientation() == RespectImageOrientation)
         return RespectImageOrientation;
 
     return DoNotRespectImageOrientation;
 }
 
-LayoutObject* LayoutObject::container(const LayoutBoxModelObject* paintInvalidationContainer, bool* paintInvalidationContainerSkipped) const
+LayoutObject* LayoutObject::container(const LayoutBoxModelObject* ancestor, bool* ancestorSkipped) const
 {
-    if (paintInvalidationContainerSkipped)
-        *paintInvalidationContainerSkipped = false;
+    if (ancestorSkipped)
+        *ancestorSkipped = false;
 
     LayoutObject* o = parent();
 
     if (isTextOrSVGChild())
         return o;
 
     EPosition pos = m_style->position();
     if (pos == FixedPosition)
-        return containerForFixedPosition(paintInvalidationContainer, paintInvalidationContainerSkipped);
+        return containerForFixedPosition(ancestor, ancestorSkipped);
 
     if (pos == AbsolutePosition)
-        return containerForAbsolutePosition(paintInvalidationContainer, paintInvalidationContainerSkipped);
+        return containerForAbsolutePosition(ancestor, ancestorSkipped);
 
     if (isColumnSpanAll()) {
         LayoutObject* multicolContainer = spannerPlaceholder()->container();
-        if (paintInvalidationContainerSkipped && paintInvalidationContainer) {
+        if (ancestorSkipped && ancestor) {
             // We jumped directly from the spanner to the multicol container. Need to check if
             // we skipped |paintInvalidationContainer| on the way.
             for (LayoutObject* walker = parent(); walker && walker != multicolContainer; walker = walker->parent()) {
-                if (walker == paintInvalidationContainer) {
-                    *paintInvalidationContainerSkipped = true;
+                if (walker == ancestor) {
+                    *ancestorSkipped = true;
                     break;
                 }
             }
         }
         return multicolContainer;
     }
 
     return o;
 }
 
@@ skipping 1083 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif