Improve positioned/percentHeight descendant/container tracking

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 25 matching lines @@
 #include "wtf/OwnPtr.h"
 
 namespace blink {
 
 class LineLayoutState;
 struct PaintInfo;
 class LayoutInline;
 class WordMeasurement;
 
 typedef WTF::ListHashSet<LayoutBox*, 16> TrackedLayoutBoxListHashSet;
-typedef WTF::HashMap<const LayoutBlock*, OwnPtr<TrackedLayoutBoxListHashSet>> TrackedDescendantsMap;
-typedef WTF::HashMap<const LayoutBox*, OwnPtr<HashSet<LayoutBlock*>>> TrackedContainerMap;
 typedef Vector<WordMeasurement, 64> WordMeasurements;
 
 enum ContainingBlockState { NewContainingBlock, SameContainingBlock };
 
+class LayoutBlockRareData : public LayoutBoxRareData {
+public:
+    // This set keeps track of the positioned objects associated with a containing
+    // block.
+    //
+    // This set is populated during layout. It is kept across layouts to handle
+    // that we skip unchanged sub-trees during layout, in such a way that we are
+    // able to lay out deeply nested out-of-flow descendants if their containing
+    // block got laid out. The set could be invalidated during style change but
+    // keeping track of containing blocks at that time is complicated (we are in
+    // the middle of recomputing the style so we can't rely on any of its
+    // information), which is why it's easier to just update it for every layout.
+    OwnPtr<TrackedLayoutBoxListHashSet> m_positionedDescendants;
+
+    // This set keeps track of the descendants whose 'height' is percentage associated
+    // with a containing block. Like |m_positionedDescendants|, it is also recomputed
+    // for every layout (see the comment above about why).
+    OwnPtr<TrackedLayoutBoxListHashSet> m_percentHeightDescendants;
+};
+
 // LayoutBlock is the class that is used by any LayoutObject
 // that is a containing block.
 // http://www.w3.org/TR/CSS2/visuren.html#containing-block
 // See also LayoutObject::containingBlock() that is the function
 // used to get the containing block of a LayoutObject.
 //
 // CSS is inconsistent and allows inline elements (LayoutInline) to be
 // containing blocks, even though they are not blocks. Our
 // implementation is as confused with inlines. See e.g.
 // LayoutObject::containingBlock() vs LayoutObject::container().
@@ skipping 87 matching lines @@
 public:
     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to LayoutBlockFlow
     virtual void deleteLineBoxTree();
 
     void addChild(LayoutObject* newChild, LayoutObject* beforeChild = nullptr) override;
     void removeChild(LayoutObject*) override;
 
     virtual void layoutBlock(bool relayoutChildren);
 
     void insertPositionedObject(LayoutBox*);
-    static void removePositionedObject(LayoutBox*);
+    void removePositionedObject(LayoutBox*);
     void removePositionedObjects(LayoutBlock*, ContainingBlockState = SameContainingBlock);
 
-    TrackedLayoutBoxListHashSet* positionedObjects() const;
+    TrackedLayoutBoxListHashSet* positionedObjects() const { return layoutBlockRareData() ? layoutBlockRareData()->m_positionedDescendants.get() : nullptr; }
     bool hasPositionedObjects() const
     {
         TrackedLayoutBoxListHashSet* objects = positionedObjects();
         return objects && !objects->isEmpty();
     }
 
     void addPercentHeightDescendant(LayoutBox*);
-    static void removePercentHeightDescendant(LayoutBox*);
-    static bool hasPercentHeightContainerMap();
-    static bool hasPercentHeightDescendant(LayoutBox*);
-    static void clearPercentHeightDescendantsFrom(LayoutBox*);
-    static void removePercentHeightDescendantIfNeeded(LayoutBox*);
+    void removePercentHeightDescendant(LayoutBox*);
+    bool hasPercentHeightDescendant(LayoutBox*);
 
-    TrackedLayoutBoxListHashSet* percentHeightDescendants() const;
+    TrackedLayoutBoxListHashSet* percentHeightDescendants() const { return layoutBlockRareData() ? layoutBlockRareData()->m_percentHeightDescendants.get() : nullptr; }
     bool hasPercentHeightDescendants() const
     {
         TrackedLayoutBoxListHashSet* descendants = percentHeightDescendants();
         return descendants && !descendants->isEmpty();
     }
 
     void notifyScrollbarThicknessChanged() { m_widthAvailableToChildrenChanged = true; }
 
     void setHasMarkupTruncation(bool b) { m_hasMarkupTruncation = b; }
     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
@@ skipping 205 matching lines @@
 
     static void collapseAnonymousBlockChild(LayoutBlock* parent, LayoutBlock* child);
     void makeChildrenInlineIfPossible();
 
     void dirtyLinesFromChangedChild(LayoutObject* child) final { m_lineBoxes.dirtyLinesFromChangedChild(LineLayoutItem(this), LineLayoutItem(child)); }
 
     void addChildIgnoringContinuation(LayoutObject* newChild, LayoutObject* beforeChild) override;
 
     bool isSelfCollapsingBlock() const override;
 
-    void insertIntoTrackedLayoutBoxMaps(LayoutBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
-    static void removeFromTrackedLayoutBoxMaps(LayoutBox* descendant, TrackedDescendantsMap*&, TrackedContainerMap*&);
-
     Node* nodeForHitTest() const;
 
     bool tryLayoutDoingPositionedMovementOnly();
 
     bool avoidsFloats() const override { return true; }
 
     bool hitTestChildren(HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction);
     // FIXME-BLOCKFLOW: Remove virtualizaion when all callers have moved to LayoutBlockFlow
     virtual bool hitTestFloats(HitTestResult&, const HitTestLocation&, const LayoutPoint&) { return false; }
 
@@ skipping 62 matching lines @@
     // applying any forced or unforced break, if needed.
     void paginatedContentWasLaidOut(LayoutUnit logicalTopOffsetAfterPagination);
 
     // Adjust from painting offsets to the local coords of this layoutObject
     void offsetForContents(LayoutPoint&) const;
 
     virtual bool updateLogicalWidthAndColumnWidth();
 
     virtual bool canCollapseAnonymousBlockChild() const { return true; }
 
+    LayoutBlockRareData* layoutBlockRareData() const { return static_cast<LayoutBlockRareData*>(rareData()); }
+    LayoutBlockRareData& ensureLayoutBlockRareData() { return static_cast<LayoutBlockRareData&>(ensureRareData()); }
+    LayoutBoxRareData* createRareData() override { return new LayoutBlockRareData; }
+
     LayoutObjectChildList m_children;
     LineBoxList m_lineBoxes; // All of the root line boxes created for this block flow.  For example, <div>Hello<br>world.</div> will have two total lines for the <div>.
 
     unsigned m_hasMarginBeforeQuirk : 1; // Note these quirk values can't be put in LayoutBlockRareData since they are set too frequently.
     unsigned m_hasMarginAfterQuirk : 1;
     unsigned m_beingDestroyed : 1;
     unsigned m_hasMarkupTruncation : 1;
     unsigned m_widthAvailableToChildrenChanged  : 1;
     mutable unsigned m_hasOnlySelfCollapsingChildren : 1;
     mutable unsigned m_descendantsWithFloatsMarkedForLayout : 1;
     mutable unsigned m_needsRecalcLogicalWidthAfterLayoutChildren : 1;
 
     // LayoutRubyBase objects need to be able to split and merge, moving their children around
     // (calling moveChildTo, moveAllChildrenTo, and makeChildrenNonInline).
     friend class LayoutRubyBase;
     // FIXME-BLOCKFLOW: Remove this when the line layout stuff has all moved out of LayoutBlock
     friend class LineBreaker;
 
     // FIXME: This is temporary as we move code that accesses block flow
     // member variables out of LayoutBlock and into LayoutBlockFlow.
     friend class LayoutBlockFlow;
 };
 
 DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutBlock, isLayoutBlock());
 
 } // namespace blink
 
 #endif // LayoutBlock_h