Introduce LayoutObject::AncestorSkipInfo.

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/)
@@ skipping 841 matching lines @@
     o->m_bitfields.setPreferredLogicalWidthsDirty(true);
     // 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.
     if (o->style()->hasOutOfFlowPosition())
       break;
     o = container;
   }
 }
 
 LayoutObject* LayoutObject::containerForAbsolutePosition(
-    const LayoutBoxModelObject* ancestor,
-    bool* ancestorSkipped,
-    bool* filterSkipped) const {
-  DCHECK(!ancestorSkipped || !*ancestorSkipped);
-  DCHECK(!filterSkipped || !*filterSkipped);
-
+    AncestorSkipInfo* skipInfo) 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 (ancestorSkipped && object == ancestor)
-      *ancestorSkipped = true;
-
-    if (filterSkipped && object->hasFilterInducingProperty())
-      *filterSkipped = true;
+    if (skipInfo)
+      skipInfo->update(*object);
   }
   return nullptr;
 }
 
 LayoutBlock* LayoutObject::containerForFixedPosition(
-    const LayoutBoxModelObject* ancestor,
-    bool* ancestorSkipped,
-    bool* filterSkipped) const {
-  DCHECK(!ancestorSkipped || !*ancestorSkipped);
-  DCHECK(!filterSkipped || !*filterSkipped);
+    AncestorSkipInfo* skipInfo) const {
   DCHECK(!isText());
 
   LayoutObject* object = parent();
   for (; object && !object->canContainFixedPositionObjects();
        object = object->parent()) {
-    if (ancestorSkipped && object == ancestor)
-      *ancestorSkipped = true;
-
-    if (filterSkipped && object->hasFilterInducingProperty())
-      *filterSkipped = true;
+    if (skipInfo)
+      skipInfo->update(*object);
   }
 
   ASSERT(!object || !object->isAnonymousBlock());
   return toLayoutBlock(object);
 }
 
 LayoutBlock* LayoutObject::containingBlockForAbsolutePosition(
-    const LayoutBoxModelObject* ancestor,
-    bool* ancestorSkipped,
-    bool* filterSkipped) const {
-  LayoutObject* object =
-      containerForAbsolutePosition(ancestor, ancestorSkipped, filterSkipped);
+    AncestorSkipInfo* skipInfo) const {
+  LayoutObject* object = containerForAbsolutePosition(skipInfo);
 
   // 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 inline directly.
   if (object && object->isInline() && !object->isAtomicInlineLevel()) {
     DCHECK(object->style()->hasInFlowPosition());
-    object = object->containingBlock(ancestor, ancestorSkipped, filterSkipped);
+    object = object->containingBlock(skipInfo);
   }
 
   if (object && !object->isLayoutBlock())
-    object = object->containingBlock(ancestor, ancestorSkipped, filterSkipped);
+    object = object->containingBlock(skipInfo);
 
   while (object && object->isAnonymousBlock())
-    object = object->containingBlock(ancestor, ancestorSkipped, filterSkipped);
+    object = object->containingBlock(skipInfo);
 
   if (!object || !object->isLayoutBlock())
     return nullptr;  // This can still happen in case of an orphaned tree
 
   return toLayoutBlock(object);
 }
 
-LayoutBlock* LayoutObject::containingBlock(const LayoutBoxModelObject* ancestor,
-                                           bool* ancestorSkipped,
-                                           bool* filterSkipped) const {
+LayoutBlock* LayoutObject::containingBlock(AncestorSkipInfo* skipInfo) const {
   LayoutObject* object = parent();
   if (!object && isLayoutScrollbarPart())
     object = toLayoutScrollbarPart(this)->layoutObjectOwningScrollbar();
   if (!isTextOrSVGChild()) {
-    if (m_style->position() == FixedPosition) {
-      return containerForFixedPosition(ancestor, ancestorSkipped,
-                                       filterSkipped);
-    }
-    if (m_style->position() == AbsolutePosition) {
-      return containingBlockForAbsolutePosition(ancestor, ancestorSkipped,
-                                                filterSkipped);
-    }
+    if (m_style->position() == FixedPosition)
+      return containerForFixedPosition(skipInfo);
+    if (m_style->position() == AbsolutePosition)
+      return containingBlockForAbsolutePosition(skipInfo);
   }
   if (isColumnSpanAll()) {
     object = spannerPlaceholder()->containingBlock();
   } else {
     while (object && ((object->isInline() && !object->isAtomicInlineLevel()) ||
                       !object->isLayoutBlock())) {
-      if (ancestorSkipped && object == ancestor)
-        *ancestorSkipped = true;
-
-      if (filterSkipped && object->hasFilterInducingProperty())
-        *filterSkipped = true;
+      if (skipInfo)
+        skipInfo->update(*object);
       object = object->parent();
     }
   }
 
   if (!object || !object->isLayoutBlock())
     return nullptr;  // This can still happen in case of an orphaned tree
 
   return toLayoutBlock(object);
 }
 
@@ skipping 1099 matching lines @@
   transformState.flatten();
   return transformState.lastPlanarQuad();
 }
 
 void LayoutObject::mapLocalToAncestor(const LayoutBoxModelObject* ancestor,
                                       TransformState& transformState,
                                       MapCoordinatesFlags mode) const {
   if (ancestor == this)
     return;
 
-  bool ancestorSkipped;
-  const LayoutObject* container = this->container(ancestor, &ancestorSkipped);
+  AncestorSkipInfo skipInfo(ancestor);
+  const LayoutObject* container = this->container(&skipInfo);
   if (!container)
     return;
 
   if (mode & ApplyContainerFlip) {
     if (isBox()) {
       mode &= ~ApplyContainerFlip;
     } else if (container->isBox()) {
       if (container->style()->isFlippedBlocksWritingMode()) {
         IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
         transformState.move(toLayoutBox(container)->flipForWritingMode(
@@ skipping 24 matching lines @@
     getTransformFromContainer(container, containerOffset, t);
     transformState.applyTransform(t, preserve3D
                                          ? TransformState::AccumulateTransform
                                          : TransformState::FlattenTransform);
   } else {
     transformState.move(containerOffset.width(), containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
   }
 
-  if (ancestorSkipped) {
+  if (skipInfo.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(container);
     transformState.move(-containerOffset.width(), -containerOffset.height(),
                         preserve3D ? TransformState::AccumulateTransform
                                    : TransformState::FlattenTransform);
     // If the ancestor is fixed, then the rect is already in its coordinates so
     // doesn't need viewport-adjusting.
@@ skipping 14 matching lines @@
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
 void LayoutObject::mapAncestorToLocal(const LayoutBoxModelObject* ancestor,
                                       TransformState& transformState,
                                       MapCoordinatesFlags mode) const {
   if (this == ancestor)
     return;
 
-  bool ancestorSkipped;
-  LayoutObject* container = this->container(ancestor, &ancestorSkipped);
+  AncestorSkipInfo skipInfo(ancestor);
+  LayoutObject* container = this->container(&skipInfo);
   if (!container)
     return;
 
   bool applyContainerFlip = false;
   if (mode & ApplyContainerFlip) {
     if (isBox()) {
       mode &= ~ApplyContainerFlip;
     } else if (container->isBox()) {
       applyContainerFlip = container->style()->isFlippedBlocksWritingMode();
       mode &= ~ApplyContainerFlip;
     }
   }
 
-  if (!ancestorSkipped)
+  if (!skipInfo.ancestorSkipped())
     container->mapAncestorToLocal(ancestor, transformState, mode);
 
   LayoutSize containerOffset = offsetFromContainer(container);
   bool preserve3D =
       mode & UseTransforms &&
       (container->style()->preserves3D() || style()->preserves3D());
   if (mode & UseTransforms && shouldUseTransformFromContainer(container)) {
     TransformationMatrix t;
     getTransformFromContainer(container, containerOffset, t);
     transformState.applyTransform(t, preserve3D
@@ skipping 14 matching lines @@
         toLayoutFlowThread(this)->visualPointToFlowThreadPoint(visualPoint));
   }
 
   if (applyContainerFlip) {
     IntPoint centerPoint = roundedIntPoint(transformState.mappedPoint());
     transformState.move(
         centerPoint -
         toLayoutBox(container)->flipForWritingMode(LayoutPoint(centerPoint)));
   }
 
-  if (ancestorSkipped) {
+  if (skipInfo.ancestorSkipped()) {
     containerOffset = ancestor->offsetFromAncestorContainer(container);
     transformState.move(-containerOffset.width(), -containerOffset.height());
     // If the ancestor is fixed, then the rect is already in its coordinates so
     // doesn't need viewport-adjusting.
     if (ancestor->style()->position() != FixedPosition &&
         container->isLayoutView() && styleRef().position() == FixedPosition) {
       LayoutSize adjustment = toLayoutView(container)->offsetForFixedPosition();
       transformState.move(adjustment.width(), adjustment.height());
     }
   }
@@ skipping 251 matching lines @@
     return RespectImageOrientation;
 
   if (layoutObject->style() &&
       layoutObject->style()->respectImageOrientation() ==
           RespectImageOrientation)
     return RespectImageOrientation;
 
   return DoNotRespectImageOrientation;
 }
 
-LayoutObject* LayoutObject::container(const LayoutBoxModelObject* ancestor,
-                                      bool* ancestorSkipped,
-                                      bool* filterSkipped) const {
-  if (ancestorSkipped)
-    *ancestorSkipped = false;
-  if (filterSkipped)
-    *filterSkipped = false;
+LayoutObject* LayoutObject::container(AncestorSkipInfo* skipInfo) const {
+  // TODO(mstensho): Get rid of this. Nobody should call this method with those
+  // flags already set.
+  if (skipInfo)
+    skipInfo->resetOutput();
 
   if (isTextOrSVGChild())
     return parent();
 
   EPosition pos = m_style->position();
   if (pos == FixedPosition)
-    return containerForFixedPosition(ancestor, ancestorSkipped, filterSkipped);
+    return containerForFixedPosition(skipInfo);
 
   if (pos == AbsolutePosition) {
-    return containerForAbsolutePosition(ancestor, ancestorSkipped,
-                                        filterSkipped);
+    return containerForAbsolutePosition(skipInfo);
   }
 
   if (isColumnSpanAll()) {
     LayoutObject* multicolContainer = spannerPlaceholder()->container();
-    if ((ancestorSkipped && ancestor) || filterSkipped) {
+    if (skipInfo) {
       // We jumped directly from the spanner to the multicol container. Need to
       // check if we skipped |ancestor| or filter/reflection on the way.
       for (LayoutObject* walker = parent();
-           walker && walker != multicolContainer; walker = walker->parent()) {
-        if (ancestorSkipped && walker == ancestor)
-          *ancestorSkipped = true;
-        if (filterSkipped && walker->hasFilterInducingProperty())
-          *filterSkipped = true;
-      }
+           walker && walker != multicolContainer; walker = walker->parent())
+        skipInfo->update(*walker);
     }
     return multicolContainer;
   }
 
   if (isFloating())
-    return containingBlock(ancestor, ancestorSkipped, filterSkipped);
+    return containingBlock(skipInfo);
 
   return parent();
 }
 
 inline LayoutObject* LayoutObject::paintInvalidationParent() const {
   if (isLayoutView())
     return LayoutAPIShim::layoutObjectFrom(frame()->ownerLayoutItem());
   return parent();
 }
 
@@ skipping 978 matching lines @@
     const blink::LayoutObject* root = object1;
     while (root->parent())
       root = root->parent();
     root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
   } else {
     WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
   }
 }
 
 #endif