Introduce LayoutObject::AncestorSkipInfo.

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 877 matching lines @@
   // implemented using flex box but should still support things like
   // first-line, first-letter and text-overflow.
   // The flex box and grid specs require that flex box and grid do not
   // support first-line|first-letter, though.
   // TODO(cbiesinger): Remove when buttons are implemented with align-items
   // instead of flex box. crbug.com/226252.
   bool behavesLikeBlockContainer() const {
     return isLayoutBlockFlow() || isLayoutButton();
   }
 
+  // May be optionally passed to container() and various other similar methods
+  // that search the ancestry for some sort of containing block. Used to
+  // determine if we skipped certain objects while walking the ancestry.
+  class AncestorSkipInfo {
+   public:
+    AncestorSkipInfo(const LayoutObject* ancestor, bool checkForFilters = false)
+        : m_ancestor(ancestor), m_checkForFilters(checkForFilters) {}
+
+    // Update skip info output based on the layout object passed.
+    void update(const LayoutObject& object) {
+      if (&object == m_ancestor)
+        m_ancestorSkipped = true;
+      if (m_checkForFilters && object.hasFilterInducingProperty())
+        m_filterSkipped = true;
+    }
+
+    // TODO(mstensho): Get rid of this. It's just a temporary thing to retain
+    // old behavior in LayoutObject::container().
+    void resetOutput() {
+      m_ancestorSkipped = false;
+      m_filterSkipped = false;
+    }
+
+    bool ancestorSkipped() const { return m_ancestorSkipped; }
+    bool filterSkipped() const {
+      DCHECK(m_checkForFilters);
+      return m_filterSkipped;
+    }
+
+   private:
+    // Input: A potential ancestor to look for. If we walk past this one while
+    // walking the ancestry in search of some containing block, ancestorSkipped
+    // will be set to true.
+    const LayoutObject* m_ancestor;
+    // Input: When set, we'll check if we skip objects with filter inducing
+    // properties.
+    bool m_checkForFilters;
+
+    // Output: Set to true if |ancestor| was walked past while walking the
+    // ancestry.
+    bool m_ancestorSkipped = false;
+    // Output: Set to true if we walked past a filter object. This will be set
+    // regardless of the value of |ancestor|.
+    bool m_filterSkipped = false;
+  };
+
   // This function returns the containing block of the object.
   // Due to CSS being inconsistent, a containing block can be a relatively
   // positioned inline, thus we can't return a LayoutBlock from this function.
   //
   // This method is extremely similar to containingBlock(), but with a few
   // notable exceptions.
   // (1) For normal flow elements, it just returns the parent.
   // (2) For absolute positioned elements, it will return a relative
   //     positioned inline. containingBlock() simply skips relpositioned inlines
   //     and lets an enclosing block handle the layout of the positioned object.
   //     This does mean that computePositionedLogicalWidth and
   //     computePositionedLogicalHeight have to use container().
   //
   // Note that floating objects don't belong to either of the above exceptions.
   //
   // This function should be used for any invalidation as it would correctly
   // walk the containing block chain. See e.g. markContainerChainForLayout.
   // It is also used for correctly sizing absolutely positioned elements
   // (point 3 above).
-  //
-  // If |ancestor| and |ancestorSkipped| are not null, on return
-  // *ancestorSkipped is true if the layoutObject returned is an ancestor of
-  // |ancestor|.
-  LayoutObject* container(const LayoutBoxModelObject* ancestor = nullptr,
-                          bool* ancestorSkipped = nullptr,
-                          bool* filterSkipped = nullptr) const;
+  LayoutObject* container(AncestorSkipInfo* = nullptr) const;
   // Finds the container as if this object is fixed-position.
-  LayoutBlock* containerForFixedPosition(
-      const LayoutBoxModelObject* ancestor = nullptr,
-      bool* ancestorSkipped = nullptr,
-      bool* filterSkipped = nullptr) const;
+  LayoutBlock* containerForFixedPosition(AncestorSkipInfo* = nullptr) const;
   // Finds the containing block as if this object is absolute-position.
   LayoutBlock* containingBlockForAbsolutePosition(
-      const LayoutBoxModelObject* ancestor = nullptr,
-      bool* ancestorSkipped = nullptr,
-      bool* filterSkipped = nullptr) const;
+      AncestorSkipInfo* = nullptr) const;
 
   virtual LayoutObject* hoverAncestor() const { return parent(); }
 
   Element* offsetParent(const Element* = nullptr) const;
 
   void markContainerChainForLayout(bool scheduleRelayout = true,
                                    SubtreeLayoutScope* = nullptr);
   void setNeedsLayout(LayoutInvalidationReasonForTracing,
                       MarkingBehavior = MarkContainerChain,
                       SubtreeLayoutScope* = nullptr);
@@ skipping 168 matching lines @@
   //   non-anonymous LayoutBlock.
   //   Note that in the previous examples, the returned LayoutBlock has no
   //   logical relationship to the original element.
   //
   // LayoutBlocks are the one that handle laying out positioned elements,
   // thus this function is important during layout, to insert the positioned
   // elements into the correct LayoutBlock.
   //
   // See container() for the function that returns the containing block.
   // See LayoutBlock.h for some extra explanations on containing blocks.
-  LayoutBlock* containingBlock(const LayoutBoxModelObject* ancestor = nullptr,
-                               bool* ancestorSkipped = nullptr,
-                               bool* filterSkipped = nullptr) const;
+  LayoutBlock* containingBlock(AncestorSkipInfo* = nullptr) const;
 
   bool canContainAbsolutePositionObjects() const {
     return m_style->canContainAbsolutePositionObjects() ||
            canContainFixedPositionObjects();
   }
   bool canContainFixedPositionObjects() const {
     return isLayoutView() || isSVGForeignObject() ||
            (isLayoutBlock() && m_style->canContainFixedPositionObjects());
   }
 
@@ skipping 893 matching lines @@
   // LayoutBox recomputeOverflow-capable. crbug.com/437012 and crbug.com/434700.
   inline void markAncestorsForOverflowRecalcIfNeeded();
 
   inline void markAncestorsForPaintInvalidation();
 
   inline void invalidateContainerPreferredLogicalWidths();
 
   void invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(
       const LayoutBoxModelObject& paintInvalidationContainer);
 
-  LayoutObject* containerForAbsolutePosition(
-      const LayoutBoxModelObject* ancestor = nullptr,
-      bool* ancestorSkipped = nullptr,
-      bool* filterSkipped = nullptr) const;
+  LayoutObject* containerForAbsolutePosition(AncestorSkipInfo* = nullptr) const;
 
   const LayoutBoxModelObject* enclosingCompositedContainer() const;
 
   LayoutFlowThread* locateFlowThreadContainingBlock() const;
   void removeFromLayoutFlowThreadRecursive(LayoutFlowThread*);
 
   ComputedStyle* cachedFirstLineStyle() const;
   StyleDifference adjustStyleDifference(StyleDifference) const;
 
   Color selectionColor(int colorProperty, const GlobalPaintFlags) const;
@@ skipping 618 matching lines @@
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h