Add m-esr52 at 52.6.0

1 files changed, 458 insertions, 0 deletions

diff --git a/layout/generic/nsGridContainerFrame.h b/layout/generic/nsGridContainerFrame.h
new file mode 100644
index 000000000..e610dfa0b
--- /dev/null
+++ b/layout/generic/nsGridContainerFrame.h
@@ -0,0 +1,458 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code is subject to the terms of the Mozilla Public License
+ * version 2.0 (the "License"). You can obtain a copy of the License at
+ * http://mozilla.org/MPL/2.0/. */
+
+/* rendering object for CSS "display: grid | inline-grid" */
+
+#ifndef nsGridContainerFrame_h___
+#define nsGridContainerFrame_h___
+
+#include "mozilla/Maybe.h"
+#include "mozilla/TypeTraits.h"
+#include "nsContainerFrame.h"
+#include "nsHashKeys.h"
+#include "nsTHashtable.h"
+
+/**
+ * Factory function.
+ * @return a newly allocated nsGridContainerFrame (infallible)
+ */
+nsContainerFrame* NS_NewGridContainerFrame(nsIPresShell* aPresShell,
+                                           nsStyleContext* aContext);
+
+namespace mozilla {
+/**
+ * The number of implicit / explicit tracks and their sizes.
+ */
+struct ComputedGridTrackInfo
+{
+  ComputedGridTrackInfo(uint32_t aNumLeadingImplicitTracks,
+                        uint32_t aNumExplicitTracks,
+                        uint32_t aStartFragmentTrack,
+                        uint32_t aEndFragmentTrack,
+                        nsTArray<nscoord>&& aPositions,
+                        nsTArray<nscoord>&& aSizes,
+                        nsTArray<uint32_t>&& aStates,
+                        nsTArray<bool>&& aRemovedRepeatTracks,
+                        uint32_t aRepeatFirstTrack)
+    : mNumLeadingImplicitTracks(aNumLeadingImplicitTracks)
+    , mNumExplicitTracks(aNumExplicitTracks)
+    , mStartFragmentTrack(aStartFragmentTrack)
+    , mEndFragmentTrack(aEndFragmentTrack)
+    , mPositions(aPositions)
+    , mSizes(aSizes)
+    , mStates(aStates)
+    , mRemovedRepeatTracks(aRemovedRepeatTracks)
+    , mRepeatFirstTrack(aRepeatFirstTrack)
+  {}
+  uint32_t mNumLeadingImplicitTracks;
+  uint32_t mNumExplicitTracks;
+  uint32_t mStartFragmentTrack;
+  uint32_t mEndFragmentTrack;
+  nsTArray<nscoord> mPositions;
+  nsTArray<nscoord> mSizes;
+  nsTArray<uint32_t> mStates;
+  nsTArray<bool> mRemovedRepeatTracks;
+  uint32_t mRepeatFirstTrack;
+};
+
+struct ComputedGridLineInfo
+{
+  explicit ComputedGridLineInfo(nsTArray<nsTArray<nsString>>&& aNames,
+                                const nsTArray<nsString>& aNamesBefore,
+                                const nsTArray<nsString>& aNamesAfter)
+    : mNames(aNames)
+    , mNamesBefore(aNamesBefore)
+    , mNamesAfter(aNamesAfter)
+  {}
+  nsTArray<nsTArray<nsString>> mNames;
+  nsTArray<nsString> mNamesBefore;
+  nsTArray<nsString> mNamesAfter;
+};
+} // namespace mozilla
+
+class nsGridContainerFrame final : public nsContainerFrame
+{
+public:
+  NS_DECL_FRAMEARENA_HELPERS
+  NS_DECL_QUERYFRAME_TARGET(nsGridContainerFrame)
+  NS_DECL_QUERYFRAME
+  typedef mozilla::ComputedGridTrackInfo ComputedGridTrackInfo;
+  typedef mozilla::ComputedGridLineInfo ComputedGridLineInfo;
+
+  // nsIFrame overrides
+  void Reflow(nsPresContext*           aPresContext,
+              ReflowOutput&     aDesiredSize,
+              const ReflowInput& aReflowInput,
+              nsReflowStatus&          aStatus) override;
+  nscoord GetMinISize(nsRenderingContext* aRenderingContext) override;
+  nscoord GetPrefISize(nsRenderingContext* aRenderingContext) override;
+  void MarkIntrinsicISizesDirty() override;
+  nsIAtom* GetType() const override;
+  bool IsFrameOfType(uint32_t aFlags) const override
+  {
+    return nsContainerFrame::IsFrameOfType(aFlags &
+             ~nsIFrame::eCanContainOverflowContainers);
+  }
+
+  void BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                        const nsRect&           aDirtyRect,
+                        const nsDisplayListSet& aLists) override;
+
+  nscoord GetLogicalBaseline(mozilla::WritingMode aWM) const override
+  {
+    if (HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) {
+      // Return a baseline synthesized from our margin-box.
+      return nsContainerFrame::GetLogicalBaseline(aWM);
+    }
+    nscoord b;
+    GetBBaseline(BaselineSharingGroup::eFirst, &b);
+    return b;
+  }
+
+  bool GetVerticalAlignBaseline(mozilla::WritingMode aWM,
+                                nscoord* aBaseline) const override
+  {
+    return GetNaturalBaselineBOffset(aWM, BaselineSharingGroup::eFirst, aBaseline);
+  }
+
+  bool GetNaturalBaselineBOffset(mozilla::WritingMode aWM,
+                                 BaselineSharingGroup aBaselineGroup,
+                                 nscoord*             aBaseline) const override
+  {
+    if (HasAnyStateBits(NS_STATE_GRID_SYNTHESIZE_BASELINE)) {
+      return false;
+    }
+    return GetBBaseline(aBaselineGroup, aBaseline);
+  }
+
+#ifdef DEBUG_FRAME_DUMP
+  nsresult GetFrameName(nsAString& aResult) const override;
+#endif
+
+  // nsContainerFrame overrides
+  bool DrainSelfOverflowList() override;
+  void AppendFrames(ChildListID aListID, nsFrameList& aFrameList) override;
+  void InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
+                    nsFrameList& aFrameList) override;
+  void RemoveFrame(ChildListID aListID, nsIFrame* aOldFrame) override;
+  uint16_t CSSAlignmentForAbsPosChild(
+            const ReflowInput& aChildRI,
+            mozilla::LogicalAxis aLogicalAxis) const override;
+
+#ifdef DEBUG
+  void SetInitialChildList(ChildListID  aListID,
+                           nsFrameList& aChildList) override;
+#endif
+
+  /**
+   * Return the containing block for aChild which MUST be an abs.pos. child
+   * of a grid container.  This is just a helper method for
+   * nsAbsoluteContainingBlock::Reflow - it's not meant to be used elsewhere.
+   */
+  static const nsRect& GridItemCB(nsIFrame* aChild);
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridItemContainingBlockRect, nsRect)
+
+  /**
+   * These properties are created by a call to
+   * nsGridContainerFrame::GetGridFrameWithComputedInfo, typically from
+   * Element::GetGridFragments.
+   */
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridColTrackInfo, ComputedGridTrackInfo)
+  const ComputedGridTrackInfo* GetComputedTemplateColumns()
+  {
+    const ComputedGridTrackInfo* info = Properties().Get(GridColTrackInfo());
+    MOZ_ASSERT(info, "Property generation wasn't requested.");
+    return info;
+  }
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridRowTrackInfo, ComputedGridTrackInfo)
+  const ComputedGridTrackInfo* GetComputedTemplateRows()
+  {
+    const ComputedGridTrackInfo* info = Properties().Get(GridRowTrackInfo());
+    MOZ_ASSERT(info, "Property generation wasn't requested.");
+    return info;
+  }
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridColumnLineInfo, ComputedGridLineInfo)
+  const ComputedGridLineInfo* GetComputedTemplateColumnLines()
+  {
+    const ComputedGridLineInfo* info = Properties().Get(GridColumnLineInfo());
+    MOZ_ASSERT(info, "Property generation wasn't requested.");
+    return info;
+  }
+
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridRowLineInfo, ComputedGridLineInfo)
+  const ComputedGridLineInfo* GetComputedTemplateRowLines()
+  {
+    const ComputedGridLineInfo* info = Properties().Get(GridRowLineInfo());
+    MOZ_ASSERT(info, "Property generation wasn't requested.");
+    return info;
+  }
+
+  typedef nsBaseHashtable<nsStringHashKey,
+                          mozilla::css::GridNamedArea,
+                          mozilla::css::GridNamedArea> ImplicitNamedAreas;
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(ImplicitNamedAreasProperty,
+                                      ImplicitNamedAreas)
+  ImplicitNamedAreas* GetImplicitNamedAreas() const {
+    return Properties().Get(ImplicitNamedAreasProperty());
+  }
+
+  typedef nsTArray<mozilla::css::GridNamedArea> ExplicitNamedAreas;
+  NS_DECLARE_FRAME_PROPERTY_DELETABLE(ExplicitNamedAreasProperty,
+                                      ExplicitNamedAreas)
+  ExplicitNamedAreas* GetExplicitNamedAreas() const {
+    return Properties().Get(ExplicitNamedAreasProperty());
+  }
+
+  /**
+   * Return a containing grid frame, and ensure it has computed grid info
+   * @return nullptr if aFrame has no grid container, or frame was destroyed
+   * @note this might destroy layout/style data since it may flush layout
+   */
+  static nsGridContainerFrame* GetGridFrameWithComputedInfo(nsIFrame* aFrame);
+
+  struct TrackSize;
+  struct GridItemInfo;
+  struct GridReflowInput;
+  template<typename Iterator> class GridItemCSSOrderIteratorT;
+  typedef GridItemCSSOrderIteratorT<nsFrameList::iterator>
+    GridItemCSSOrderIterator;
+  typedef GridItemCSSOrderIteratorT<nsFrameList::reverse_iterator>
+    ReverseGridItemCSSOrderIterator;
+  struct FindItemInGridOrderResult
+  {
+    // The first(last) item in (reverse) grid order.
+    const GridItemInfo* mItem;
+    // Does the above item span the first(last) track?
+    bool mIsInEdgeTrack;
+  };
+protected:
+  static const uint32_t kAutoLine;
+  // The maximum line number, in the zero-based translated grid.
+  static const uint32_t kTranslatedMaxLine;
+  typedef mozilla::LogicalPoint LogicalPoint;
+  typedef mozilla::LogicalRect LogicalRect;
+  typedef mozilla::LogicalSize LogicalSize;
+  typedef mozilla::WritingMode WritingMode;
+  typedef mozilla::css::GridNamedArea GridNamedArea;
+  typedef mozilla::layout::AutoFrameListPtr AutoFrameListPtr;
+  typedef nsLayoutUtils::IntrinsicISizeType IntrinsicISizeType;
+  struct Grid;
+  struct GridArea;
+  class LineNameMap;
+  struct LineRange;
+  struct SharedGridData;
+  struct TrackSizingFunctions;
+  struct Tracks;
+  struct TranslatedLineRange;
+  friend nsContainerFrame* NS_NewGridContainerFrame(nsIPresShell* aPresShell,
+                                                    nsStyleContext* aContext);
+  explicit nsGridContainerFrame(nsStyleContext* aContext)
+    : nsContainerFrame(aContext)
+    , mCachedMinISize(NS_INTRINSIC_WIDTH_UNKNOWN)
+    , mCachedPrefISize(NS_INTRINSIC_WIDTH_UNKNOWN)
+  {
+    mBaseline[0][0] = NS_INTRINSIC_WIDTH_UNKNOWN;
+    mBaseline[0][1] = NS_INTRINSIC_WIDTH_UNKNOWN;
+    mBaseline[1][0] = NS_INTRINSIC_WIDTH_UNKNOWN;
+    mBaseline[1][1] = NS_INTRINSIC_WIDTH_UNKNOWN;
+  }
+
+  /**
+   * XXX temporary - move the ImplicitNamedAreas stuff to the style system.
+   * The implicit area names that come from x-start .. x-end lines in
+   * grid-template-columns / grid-template-rows are stored in this frame
+   * property when needed, as a ImplicitNamedAreas* value.
+   */
+  void InitImplicitNamedAreas(const nsStylePosition* aStyle);
+  void AddImplicitNamedAreas(const nsTArray<nsTArray<nsString>>& aLineNameLists);
+
+  /**
+   * Reflow and place our children.
+   * @return the consumed size of all of this grid container's continuations
+   *         so far including this frame
+   */
+  nscoord ReflowChildren(GridReflowInput&     aState,
+                         const LogicalRect&   aContentArea,
+                         ReflowOutput& aDesiredSize,
+                         nsReflowStatus&      aStatus);
+
+  /**
+   * Helper for GetMinISize / GetPrefISize.
+   */
+  nscoord IntrinsicISize(nsRenderingContext* aRenderingContext,
+                         IntrinsicISizeType  aConstraint);
+
+  // Helper for AppendFrames / InsertFrames.
+  void NoteNewChildren(ChildListID aListID, const nsFrameList& aFrameList);
+
+  // Helper to move child frames into the kOverflowList.
+  void MergeSortedOverflow(nsFrameList& aList);
+  // Helper to move child frames into the kExcessOverflowContainersList:.
+  void MergeSortedExcessOverflowContainers(nsFrameList& aList);
+
+  bool GetBBaseline(BaselineSharingGroup aBaselineGroup, nscoord* aResult) const
+  {
+    *aResult = mBaseline[mozilla::eLogicalAxisBlock][aBaselineGroup];
+    return true;
+  }
+  bool GetIBaseline(BaselineSharingGroup aBaselineGroup, nscoord* aResult) const
+  {
+    *aResult = mBaseline[mozilla::eLogicalAxisInline][aBaselineGroup];
+    return true;
+  }
+
+  /**
+   * Calculate this grid container's baselines.
+   * @param aBaselineSet which baseline(s) to derive from a baseline-group or
+   * items; a baseline not included is synthesized from the border-box instead.
+   * @param aFragmentStartTrack is the first track in this fragment in the same
+   * axis as aMajor.  Pass zero if that's not the axis we're fragmenting in.
+   * @param aFirstExcludedTrack should be the first track in the next fragment
+   * or one beyond the final track in the last fragment, in aMajor's axis.
+   * Pass the number of tracks if that's not the axis we're fragmenting in.
+   */
+  enum BaselineSet : uint32_t {
+    eNone =  0x0,
+    eFirst = 0x1,
+    eLast  = 0x2,
+    eBoth  = eFirst | eLast,
+  };
+  void CalculateBaselines(BaselineSet                   aBaselineSet,
+                          GridItemCSSOrderIterator*     aIter,
+                          const nsTArray<GridItemInfo>* aGridItems,
+                          const Tracks&    aTracks,
+                          uint32_t         aFragmentStartTrack,
+                          uint32_t         aFirstExcludedTrack,
+                          WritingMode      aWM,
+                          const nsSize&    aCBPhysicalSize,
+                          nscoord          aCBBorderPaddingStart,
+                          nscoord          aCBBorderPaddingStartEnd,
+                          nscoord          aCBSize);
+
+  /**
+   * Synthesize a Grid container baseline for aGroup.
+   */
+  nscoord SynthesizeBaseline(const FindItemInGridOrderResult& aItem,
+                             mozilla::LogicalAxis aAxis,
+                             BaselineSharingGroup aGroup,
+                             const nsSize&        aCBPhysicalSize,
+                             nscoord              aCBSize,
+                             WritingMode          aCBWM);
+  /**
+   * Find the first item in Grid Order in this fragment.
+   * https://drafts.csswg.org/css-grid/#grid-order
+   * @param aFragmentStartTrack is the first track in this fragment in the same
+   * axis as aMajor.  Pass zero if that's not the axis we're fragmenting in.
+   */
+  static FindItemInGridOrderResult
+  FindFirstItemInGridOrder(GridItemCSSOrderIterator& aIter,
+                           const nsTArray<GridItemInfo>& aGridItems,
+                           LineRange GridArea::* aMajor,
+                           LineRange GridArea::* aMinor,
+                           uint32_t aFragmentStartTrack);
+  /**
+   * Find the last item in Grid Order in this fragment.
+   * @param aFragmentStartTrack is the first track in this fragment in the same
+   * axis as aMajor.  Pass zero if that's not the axis we're fragmenting in.
+   * @param aFirstExcludedTrack should be the first track in the next fragment
+   * or one beyond the final track in the last fragment, in aMajor's axis.
+   * Pass the number of tracks if that's not the axis we're fragmenting in.
+   */
+  static FindItemInGridOrderResult
+  FindLastItemInGridOrder(ReverseGridItemCSSOrderIterator& aIter,
+                          const nsTArray<GridItemInfo>& aGridItems,
+                          LineRange GridArea::* aMajor,
+                          LineRange GridArea::* aMinor,
+                          uint32_t aFragmentStartTrack,
+                          uint32_t aFirstExcludedTrack);
+
+#ifdef DEBUG
+  void SanityCheckGridItemsBeforeReflow() const;
+#endif // DEBUG
+
+private:
+  // Helpers for ReflowChildren
+  struct Fragmentainer {
+    /**
+     * The distance from the first grid container fragment's block-axis content
+     * edge to the fragmentainer end.
+     */
+    nscoord mToFragmentainerEnd;
+    /**
+     * True if the current fragment is at the start of the fragmentainer.
+     */
+    bool mIsTopOfPage;
+    /**
+     * Is there a Class C break opportunity at the start content edge?
+     */
+    bool mCanBreakAtStart;
+    /**
+     * Is there a Class C break opportunity at the end content edge?
+     */
+    bool mCanBreakAtEnd;
+    /**
+     * Is the grid container's block-size unconstrained?
+     */
+    bool mIsAutoBSize;
+  };
+
+  mozilla::Maybe<nsGridContainerFrame::Fragmentainer>
+    GetNearestFragmentainer(const GridReflowInput& aState) const;
+
+  // @return the consumed size of all continuations so far including this frame
+  nscoord ReflowInFragmentainer(GridReflowInput&     aState,
+                                const LogicalRect&   aContentArea,
+                                ReflowOutput& aDesiredSize,
+                                nsReflowStatus&      aStatus,
+                                Fragmentainer&       aFragmentainer,
+                                const nsSize&        aContainerSize);
+
+  // Helper for ReflowInFragmentainer
+  // @return the consumed size of all continuations so far including this frame
+  nscoord ReflowRowsInFragmentainer(GridReflowInput&     aState,
+                                    const LogicalRect&   aContentArea,
+                                    ReflowOutput& aDesiredSize,
+                                    nsReflowStatus&      aStatus,
+                                    Fragmentainer&       aFragmentainer,
+                                    const nsSize&        aContainerSize,
+                                    const nsTArray<const GridItemInfo*>& aItems,
+                                    uint32_t             aStartRow,
+                                    uint32_t             aEndRow,
+                                    nscoord              aBSize,
+                                    nscoord              aAvailableSize);
+
+  // Helper for ReflowChildren / ReflowInFragmentainer
+  void ReflowInFlowChild(nsIFrame*               aChild,
+                         const GridItemInfo*     aGridItemInfo,
+                         nsSize                  aContainerSize,
+                         mozilla::Maybe<nscoord> aStretchBSize,
+                         const Fragmentainer*    aFragmentainer,
+                         const GridReflowInput&  aState,
+                         const LogicalRect&      aContentArea,
+                         ReflowOutput&    aDesiredSize,
+                         nsReflowStatus&         aStatus);
+
+  /**
+   * Cached values to optimize GetMinISize/GetPrefISize.
+   */
+  nscoord mCachedMinISize;
+  nscoord mCachedPrefISize;
+
+  // Our baselines, one per BaselineSharingGroup per axis.
+  nscoord mBaseline[2/*LogicalAxis*/][2/*BaselineSharingGroup*/];
+
+#ifdef DEBUG
+  // If true, NS_STATE_GRID_DID_PUSH_ITEMS may be set even though all pushed
+  // frames may have been removed.  This is used to suppress an assertion
+  // in case RemoveFrame removed all associated child frames.
+  bool mDidPushItemsBitMayLie;
+#endif
+};
+
+#endif /* nsGridContainerFrame_h___ */