Add m-esr52 at 52.6.0

1 files changed, 836 insertions, 0 deletions

diff --git a/layout/generic/nsRubyBaseContainerFrame.cpp b/layout/generic/nsRubyBaseContainerFrame.cpp
new file mode 100644
index 000000000..401b7d576
--- /dev/null
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -0,0 +1,836 @@
+/* -*- 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: ruby-base-container" */
+
+#include "nsRubyBaseContainerFrame.h"
+#include "nsRubyTextContainerFrame.h"
+#include "nsRubyBaseFrame.h"
+#include "nsRubyTextFrame.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/WritingModes.h"
+#include "nsLayoutUtils.h"
+#include "nsLineLayout.h"
+#include "nsPresContext.h"
+#include "nsStyleContext.h"
+#include "nsStyleStructInlines.h"
+#include "nsTextFrame.h"
+#include "RubyUtils.h"
+
+using namespace mozilla;
+
+//----------------------------------------------------------------------
+
+// Frame class boilerplate
+// =======================
+
+NS_QUERYFRAME_HEAD(nsRubyBaseContainerFrame)
+  NS_QUERYFRAME_ENTRY(nsRubyBaseContainerFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(nsRubyBaseContainerFrame)
+
+nsContainerFrame*
+NS_NewRubyBaseContainerFrame(nsIPresShell* aPresShell,
+                             nsStyleContext* aContext)
+{
+  return new (aPresShell) nsRubyBaseContainerFrame(aContext);
+}
+
+
+//----------------------------------------------------------------------
+
+// nsRubyBaseContainerFrame Method Implementations
+// ===============================================
+
+nsIAtom*
+nsRubyBaseContainerFrame::GetType() const
+{
+  return nsGkAtoms::rubyBaseContainerFrame;
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult
+nsRubyBaseContainerFrame::GetFrameName(nsAString& aResult) const
+{
+  return MakeFrameName(NS_LITERAL_STRING("RubyBaseContainer"), aResult);
+}
+#endif
+
+static gfxBreakPriority
+LineBreakBefore(nsIFrame* aFrame,
+                DrawTarget* aDrawTarget,
+                nsIFrame* aLineContainerFrame,
+                const nsLineList::iterator* aLine)
+{
+  for (nsIFrame* child = aFrame; child;
+       child = child->PrincipalChildList().FirstChild()) {
+    if (!child->CanContinueTextRun()) {
+      // It is not an inline element. We can break before it.
+      return gfxBreakPriority::eNormalBreak;
+    }
+    if (child->GetType() != nsGkAtoms::textFrame) {
+      continue;
+    }
+
+    auto textFrame = static_cast<nsTextFrame*>(child);
+    gfxSkipCharsIterator iter =
+      textFrame->EnsureTextRun(nsTextFrame::eInflated, aDrawTarget,
+                               aLineContainerFrame, aLine);
+    iter.SetOriginalOffset(textFrame->GetContentOffset());
+    uint32_t pos = iter.GetSkippedOffset();
+    gfxTextRun* textRun = textFrame->GetTextRun(nsTextFrame::eInflated);
+    if (pos >= textRun->GetLength()) {
+      // The text frame contains no character at all.
+      return gfxBreakPriority::eNoBreak;
+    }
+    // Return whether we can break before the first character.
+    if (textRun->CanBreakLineBefore(pos)) {
+      return gfxBreakPriority::eNormalBreak;
+    }
+    // Check whether we can wrap word here.
+    const nsStyleText* textStyle = textFrame->StyleText();
+    if (textStyle->WordCanWrap(textFrame) && textRun->IsClusterStart(pos)) {
+      return gfxBreakPriority::eWordWrapBreak;
+    }
+    // We cannot break before.
+    return gfxBreakPriority::eNoBreak;
+  }
+  // Neither block, nor text frame is found as a leaf. We won't break
+  // before this base frame. It is the behavior of empty spans.
+  return gfxBreakPriority::eNoBreak;
+}
+
+static void
+GetIsLineBreakAllowed(nsIFrame* aFrame, bool aIsLineBreakable,
+                      bool* aAllowInitialLineBreak, bool* aAllowLineBreak)
+{
+  nsIFrame* parent = aFrame->GetParent();
+  bool lineBreakSuppressed = parent->StyleContext()->ShouldSuppressLineBreak();
+  // Allow line break between ruby bases when white-space allows,
+  // we are not inside a nested ruby, and there is no span.
+  bool allowLineBreak = !lineBreakSuppressed &&
+                        aFrame->StyleText()->WhiteSpaceCanWrap(aFrame);
+  bool allowInitialLineBreak = allowLineBreak;
+  if (!aFrame->GetPrevInFlow()) {
+    allowInitialLineBreak = !lineBreakSuppressed &&
+                            parent->StyleText()->WhiteSpaceCanWrap(parent);
+  }
+  if (!aIsLineBreakable) {
+    allowInitialLineBreak = false;
+  }
+  *aAllowInitialLineBreak = allowInitialLineBreak;
+  *aAllowLineBreak = allowLineBreak;
+}
+
+/**
+ * @param aBaseISizeData is an in/out param. This method updates the
+ * `skipWhitespace` and `trailingWhitespace` fields of the struct with
+ * the base level frame. Note that we don't need to do the same thing
+ * for ruby text frames, because they are text run container themselves
+ * (see nsTextFrame.cpp:BuildTextRuns), and thus no whitespace collapse
+ * happens across the boundary of those frames.
+ */
+static nscoord
+CalculateColumnPrefISize(nsRenderingContext* aRenderingContext,
+                         const RubyColumnEnumerator& aEnumerator,
+                         nsIFrame::InlineIntrinsicISizeData* aBaseISizeData)
+{
+  nscoord max = 0;
+  uint32_t levelCount = aEnumerator.GetLevelCount();
+  for (uint32_t i = 0; i < levelCount; i++) {
+    nsIFrame* frame = aEnumerator.GetFrameAtLevel(i);
+    if (frame) {
+      nsIFrame::InlinePrefISizeData data;
+      if (i == 0) {
+        data.SetLineContainer(aBaseISizeData->LineContainer());
+        data.mSkipWhitespace = aBaseISizeData->mSkipWhitespace;
+        data.mTrailingWhitespace = aBaseISizeData->mTrailingWhitespace;
+      } else {
+        // The line container of ruby text frames is their parent,
+        // ruby text container frame.
+        data.SetLineContainer(frame->GetParent());
+      }
+      frame->AddInlinePrefISize(aRenderingContext, &data);
+      MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines");
+      max = std::max(max, data.mCurrentLine);
+      if (i == 0) {
+        aBaseISizeData->mSkipWhitespace = data.mSkipWhitespace;
+        aBaseISizeData->mTrailingWhitespace = data.mTrailingWhitespace;
+      }
+    }
+  }
+  return max;
+}
+
+// FIXME Currently we use pref isize of ruby content frames for
+//       computing min isize of ruby frame, which may cause problem.
+//       See bug 1134945.
+/* virtual */ void
+nsRubyBaseContainerFrame::AddInlineMinISize(
+  nsRenderingContext *aRenderingContext, nsIFrame::InlineMinISizeData *aData)
+{
+  AutoRubyTextContainerArray textContainers(this);
+
+  for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) {
+    if (textContainers[i]->IsSpanContainer()) {
+      // Since spans are not breakable internally, use our pref isize
+      // directly if there is any span.
+      nsIFrame::InlinePrefISizeData data;
+      data.SetLineContainer(aData->LineContainer());
+      data.mSkipWhitespace = aData->mSkipWhitespace;
+      data.mTrailingWhitespace = aData->mTrailingWhitespace;
+      AddInlinePrefISize(aRenderingContext, &data);
+      aData->mCurrentLine += data.mCurrentLine;
+      if (data.mCurrentLine > 0) {
+        aData->mAtStartOfLine = false;
+      }
+      aData->mSkipWhitespace = data.mSkipWhitespace;
+      aData->mTrailingWhitespace = data.mTrailingWhitespace;
+      return;
+    }
+  }
+
+  bool firstFrame = true;
+  bool allowInitialLineBreak, allowLineBreak;
+  GetIsLineBreakAllowed(this, !aData->mAtStartOfLine,
+                        &allowInitialLineBreak, &allowLineBreak);
+  for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
+    RubyColumnEnumerator enumerator(
+      static_cast<nsRubyBaseContainerFrame*>(frame), textContainers);
+    for (; !enumerator.AtEnd(); enumerator.Next()) {
+      if (firstFrame ? allowInitialLineBreak : allowLineBreak) {
+        nsIFrame* baseFrame = enumerator.GetFrameAtLevel(0);
+        if (baseFrame) {
+          gfxBreakPriority breakPriority =
+            LineBreakBefore(baseFrame, aRenderingContext->GetDrawTarget(),
+                            nullptr, nullptr);
+          if (breakPriority != gfxBreakPriority::eNoBreak) {
+            aData->OptionallyBreak();
+          }
+        }
+      }
+      firstFrame = false;
+      nscoord isize = CalculateColumnPrefISize(aRenderingContext,
+                                               enumerator, aData);
+      aData->mCurrentLine += isize;
+      if (isize > 0) {
+        aData->mAtStartOfLine = false;
+      }
+    }
+  }
+}
+
+/* virtual */ void
+nsRubyBaseContainerFrame::AddInlinePrefISize(
+  nsRenderingContext *aRenderingContext, nsIFrame::InlinePrefISizeData *aData)
+{
+  AutoRubyTextContainerArray textContainers(this);
+
+  nscoord sum = 0;
+  for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
+    RubyColumnEnumerator enumerator(
+      static_cast<nsRubyBaseContainerFrame*>(frame), textContainers);
+    for (; !enumerator.AtEnd(); enumerator.Next()) {
+      sum += CalculateColumnPrefISize(aRenderingContext, enumerator, aData);
+    }
+  }
+  for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) {
+    if (textContainers[i]->IsSpanContainer()) {
+      nsIFrame* frame = textContainers[i]->PrincipalChildList().FirstChild();
+      nsIFrame::InlinePrefISizeData data;
+      frame->AddInlinePrefISize(aRenderingContext, &data);
+      MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines");
+      sum = std::max(sum, data.mCurrentLine);
+    }
+  }
+  aData->mCurrentLine += sum;
+}
+
+/* virtual */ bool 
+nsRubyBaseContainerFrame::IsFrameOfType(uint32_t aFlags) const 
+{
+  if (aFlags & eSupportsCSSTransforms) {
+    return false;
+  }
+  return nsContainerFrame::IsFrameOfType(aFlags &
+         ~(nsIFrame::eLineParticipant));
+}
+
+/* virtual */ bool
+nsRubyBaseContainerFrame::CanContinueTextRun() const
+{
+  return true;
+}
+
+/* virtual */ LogicalSize
+nsRubyBaseContainerFrame::ComputeSize(nsRenderingContext *aRenderingContext,
+                                      WritingMode aWM,
+                                      const LogicalSize& aCBSize,
+                                      nscoord aAvailableISize,
+                                      const LogicalSize& aMargin,
+                                      const LogicalSize& aBorder,
+                                      const LogicalSize& aPadding,
+                                      ComputeSizeFlags aFlags)
+{
+  // Ruby base container frame is inline,
+  // hence don't compute size before reflow.
+  return LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+}
+
+/* virtual */ nscoord
+nsRubyBaseContainerFrame::GetLogicalBaseline(WritingMode aWritingMode) const
+{
+  return mBaseline;
+}
+
+struct nsRubyBaseContainerFrame::RubyReflowInput
+{
+  bool mAllowInitialLineBreak;
+  bool mAllowLineBreak;
+  const AutoRubyTextContainerArray& mTextContainers;
+  const ReflowInput& mBaseReflowInput;
+  const nsTArray<UniquePtr<ReflowInput>>& mTextReflowInputs;
+};
+
+/* virtual */ void
+nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext,
+                                 ReflowOutput& aDesiredSize,
+                                 const ReflowInput& aReflowInput,
+                                 nsReflowStatus& aStatus)
+{
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+  aStatus = NS_FRAME_COMPLETE;
+
+  if (!aReflowInput.mLineLayout) {
+    NS_ASSERTION(
+      aReflowInput.mLineLayout,
+      "No line layout provided to RubyBaseContainerFrame reflow method.");
+    return;
+  }
+
+  mDescendantLeadings.Reset();
+
+  MoveOverflowToChildList();
+  // Ask text containers to drain overflows
+  AutoRubyTextContainerArray textContainers(this);
+  const uint32_t rtcCount = textContainers.Length();
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    textContainers[i]->MoveOverflowToChildList();
+  }
+
+  WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
+  LogicalSize availSize(lineWM, aReflowInput.AvailableISize(),
+                        aReflowInput.AvailableBSize());
+
+  // We have a reflow state and a line layout for each RTC.
+  // They are conceptually the state of the RTCs, but we don't actually
+  // reflow those RTCs in this code. These two arrays are holders of
+  // the reflow states and line layouts.
+  // Since there are pointers refer to reflow states and line layouts,
+  // it is necessary to guarantee that they won't be moved. For this
+  // reason, they are wrapped in UniquePtr here.
+  AutoTArray<UniquePtr<ReflowInput>, RTC_ARRAY_SIZE> reflowInputs;
+  AutoTArray<UniquePtr<nsLineLayout>, RTC_ARRAY_SIZE> lineLayouts;
+  reflowInputs.SetCapacity(rtcCount);
+  lineLayouts.SetCapacity(rtcCount);
+
+  // Begin the line layout for each ruby text container in advance.
+  bool hasSpan = false;
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    nsRubyTextContainerFrame* textContainer = textContainers[i];
+    if (textContainer->IsSpanContainer()) {
+      hasSpan = true;
+    }
+
+    ReflowInput* reflowInput = new ReflowInput(
+      aPresContext, *aReflowInput.mParentReflowInput, textContainer,
+      availSize.ConvertTo(textContainer->GetWritingMode(), lineWM));
+    reflowInputs.AppendElement(reflowInput);
+    nsLineLayout* lineLayout = new nsLineLayout(aPresContext,
+                                                reflowInput->mFloatManager,
+                                                reflowInput, nullptr,
+                                                aReflowInput.mLineLayout);
+    lineLayout->SetSuppressLineWrap(true);
+    lineLayouts.AppendElement(lineLayout);
+
+    // Line number is useless for ruby text
+    // XXX nullptr here may cause problem, see comments for
+    //     nsLineLayout::mBlockRI and nsLineLayout::AddFloat
+    lineLayout->Init(nullptr, reflowInput->CalcLineHeight(), -1);
+    reflowInput->mLineLayout = lineLayout;
+
+    // Border and padding are suppressed on ruby text containers.
+    // If the writing mode is vertical-rl, the horizontal position of
+    // rt frames will be updated when reflowing this text container,
+    // hence leave container size 0 here for now.
+    lineLayout->BeginLineReflow(0, 0, reflowInput->ComputedISize(),
+                                NS_UNCONSTRAINEDSIZE,
+                                false, false, lineWM, nsSize(0, 0));
+    lineLayout->AttachRootFrameToBaseLineLayout();
+  }
+
+  aReflowInput.mLineLayout->BeginSpan(this, &aReflowInput,
+                                      0, aReflowInput.AvailableISize(),
+                                      &mBaseline);
+
+  bool allowInitialLineBreak, allowLineBreak;
+  GetIsLineBreakAllowed(this, aReflowInput.mLineLayout->LineIsBreakable(),
+                        &allowInitialLineBreak, &allowLineBreak);
+
+  nscoord isize = 0;
+  // Reflow columns excluding any span
+  RubyReflowInput reflowInput = {
+    allowInitialLineBreak, allowLineBreak && !hasSpan,
+    textContainers, aReflowInput, reflowInputs
+  };
+  isize = ReflowColumns(reflowInput, aStatus);
+  DebugOnly<nscoord> lineSpanSize = aReflowInput.mLineLayout->EndSpan(this);
+  aDesiredSize.ISize(lineWM) = isize;
+  // When there are no frames inside the ruby base container, EndSpan
+  // will return 0. However, in this case, the actual width of the
+  // container could be non-zero because of non-empty ruby annotations.
+  // XXX When bug 765861 gets fixed, this warning should be upgraded.
+  NS_WARNING_ASSERTION(
+    NS_INLINE_IS_BREAK(aStatus) || isize == lineSpanSize || mFrames.IsEmpty(),
+    "bad isize");
+
+  // If there exists any span, the columns must either be completely
+  // reflowed, or be not reflowed at all.
+  MOZ_ASSERT(NS_INLINE_IS_BREAK_BEFORE(aStatus) ||
+             NS_FRAME_IS_COMPLETE(aStatus) || !hasSpan);
+  if (!NS_INLINE_IS_BREAK_BEFORE(aStatus) &&
+      NS_FRAME_IS_COMPLETE(aStatus) && hasSpan) {
+    // Reflow spans
+    RubyReflowInput reflowInput = {
+      false, false, textContainers, aReflowInput, reflowInputs
+    };
+    nscoord spanISize = ReflowSpans(reflowInput);
+    isize = std::max(isize, spanISize);
+  }
+
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    // It happens before the ruby text container is reflowed, and that
+    // when it is reflowed, it will just use this size.
+    nsRubyTextContainerFrame* textContainer = textContainers[i];
+    nsLineLayout* lineLayout = lineLayouts[i].get();
+
+    RubyUtils::ClearReservedISize(textContainer);
+    nscoord rtcISize = lineLayout->GetCurrentICoord();
+    // Only span containers and containers with collapsed annotations
+    // need reserving isize. For normal ruby text containers, their
+    // children will be expanded properly. We only need to expand their
+    // own size.
+    if (!textContainer->IsSpanContainer()) {
+      rtcISize = isize;
+    } else if (isize > rtcISize) {
+      RubyUtils::SetReservedISize(textContainer, isize - rtcISize);
+    }
+
+    lineLayout->VerticalAlignLine();
+    textContainer->SetISize(rtcISize);
+    lineLayout->EndLineReflow();
+  }
+
+  // Border and padding are suppressed on ruby base container,
+  // create a fake borderPadding for setting BSize.
+  WritingMode frameWM = aReflowInput.GetWritingMode();
+  LogicalMargin borderPadding(frameWM);
+  nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize,
+                                         borderPadding, lineWM, frameWM);
+}
+
+/**
+ * This struct stores the continuations after this frame and
+ * corresponding text containers. It is used to speed up looking
+ * ahead for nonempty continuations.
+ */
+struct MOZ_STACK_CLASS nsRubyBaseContainerFrame::PullFrameState
+{
+  ContinuationTraversingState mBase;
+  AutoTArray<ContinuationTraversingState, RTC_ARRAY_SIZE> mTexts;
+  const AutoRubyTextContainerArray& mTextContainers;
+
+  PullFrameState(nsRubyBaseContainerFrame* aBaseContainer,
+                 const AutoRubyTextContainerArray& aTextContainers);
+};
+
+nscoord
+nsRubyBaseContainerFrame::ReflowColumns(const RubyReflowInput& aReflowInput,
+                                        nsReflowStatus& aStatus)
+{
+  nsLineLayout* lineLayout = aReflowInput.mBaseReflowInput.mLineLayout;
+  const uint32_t rtcCount = aReflowInput.mTextContainers.Length();
+  nscoord icoord = lineLayout->GetCurrentICoord();
+  MOZ_ASSERT(icoord == 0, "border/padding of rbc should have been suppressed");
+  nsReflowStatus reflowStatus = NS_FRAME_COMPLETE;
+  aStatus = NS_FRAME_COMPLETE;
+
+  uint32_t columnIndex = 0;
+  RubyColumn column;
+  column.mTextFrames.SetCapacity(rtcCount);
+  RubyColumnEnumerator e(this, aReflowInput.mTextContainers);
+  for (; !e.AtEnd(); e.Next()) {
+    e.GetColumn(column);
+    icoord += ReflowOneColumn(aReflowInput, columnIndex, column, reflowStatus);
+    if (!NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) {
+      columnIndex++;
+    }
+    if (NS_INLINE_IS_BREAK(reflowStatus)) {
+      break;
+    }
+    // We are not handling overflow here.
+    MOZ_ASSERT(reflowStatus == NS_FRAME_COMPLETE);
+  }
+
+  bool isComplete = false;
+  PullFrameState pullFrameState(this, aReflowInput.mTextContainers);
+  while (!NS_INLINE_IS_BREAK(reflowStatus)) {
+    // We are not handling overflow here.
+    MOZ_ASSERT(reflowStatus == NS_FRAME_COMPLETE);
+
+    // Try pull some frames from next continuations. This call replaces
+    // frames in |column| with the frame pulled in each level.
+    PullOneColumn(lineLayout, pullFrameState, column, isComplete);
+    if (isComplete) {
+      // No more frames can be pulled.
+      break;
+    }
+    icoord += ReflowOneColumn(aReflowInput, columnIndex, column, reflowStatus);
+    if (!NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) {
+      columnIndex++;
+    }
+  }
+
+  if (!e.AtEnd() && NS_INLINE_IS_BREAK_AFTER(reflowStatus)) {
+    // The current column has been successfully placed.
+    // Skip to the next column and mark break before.
+    e.Next();
+    e.GetColumn(column);
+    reflowStatus = NS_INLINE_LINE_BREAK_BEFORE();
+  }
+  if (!e.AtEnd() || (GetNextInFlow() && !isComplete)) {
+    NS_FRAME_SET_INCOMPLETE(aStatus);
+  }
+
+  if (NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) {
+    if (!columnIndex || !aReflowInput.mAllowLineBreak) {
+      // If no column has been placed yet, or we have any span,
+      // the whole container should be in the next line.
+      aStatus = NS_INLINE_LINE_BREAK_BEFORE();
+      return 0;
+    }
+    aStatus = NS_INLINE_LINE_BREAK_AFTER(aStatus);
+    MOZ_ASSERT(NS_FRAME_IS_COMPLETE(aStatus) || aReflowInput.mAllowLineBreak);
+
+    // If we are on an intra-level whitespace column, null values in
+    // column.mBaseFrame and column.mTextFrames don't represent the
+    // end of the frame-sibling-chain at that level -- instead, they
+    // represent an anonymous empty intra-level whitespace box. It is
+    // likely that there are frames in the next column (which can't be
+    // intra-level whitespace). Those frames should be pushed as well.
+    Maybe<RubyColumn> nextColumn;
+    if (column.mIsIntraLevelWhitespace && !e.AtEnd()) {
+      e.Next();
+      nextColumn.emplace();
+      e.GetColumn(nextColumn.ref());
+    }
+    nsIFrame* baseFrame = column.mBaseFrame;
+    if (!baseFrame & nextColumn.isSome()) {
+      baseFrame = nextColumn->mBaseFrame;
+    }
+    if (baseFrame) {
+      PushChildren(baseFrame, baseFrame->GetPrevSibling());
+    }
+    for (uint32_t i = 0; i < rtcCount; i++) {
+      nsRubyTextFrame* textFrame = column.mTextFrames[i];
+      if (!textFrame && nextColumn.isSome()) {
+        textFrame = nextColumn->mTextFrames[i];
+      }
+      if (textFrame) {
+        aReflowInput.mTextContainers[i]->PushChildren(
+          textFrame, textFrame->GetPrevSibling());
+      }
+    }
+  } else if (NS_INLINE_IS_BREAK_AFTER(reflowStatus)) {
+    // |reflowStatus| being break after here may only happen when
+    // there is a break after the column just pulled, or the whole
+    // segment has been completely reflowed. In those cases, we do
+    // not need to push anything.
+    MOZ_ASSERT(e.AtEnd());
+    aStatus = NS_INLINE_LINE_BREAK_AFTER(aStatus);
+  }
+
+  return icoord;
+}
+
+nscoord
+nsRubyBaseContainerFrame::ReflowOneColumn(const RubyReflowInput& aReflowInput,
+                                          uint32_t aColumnIndex,
+                                          const RubyColumn& aColumn,
+                                          nsReflowStatus& aStatus)
+{
+  const ReflowInput& baseReflowInput = aReflowInput.mBaseReflowInput;
+  const auto& textReflowInputs = aReflowInput.mTextReflowInputs;
+  nscoord istart = baseReflowInput.mLineLayout->GetCurrentICoord();
+
+  if (aColumn.mBaseFrame) {
+    bool allowBreakBefore = aColumnIndex ?
+      aReflowInput.mAllowLineBreak : aReflowInput.mAllowInitialLineBreak;
+    if (allowBreakBefore) {
+      gfxBreakPriority breakPriority = LineBreakBefore(
+        aColumn.mBaseFrame, baseReflowInput.mRenderingContext->GetDrawTarget(),
+        baseReflowInput.mLineLayout->LineContainerFrame(),
+        baseReflowInput.mLineLayout->GetLine());
+      if (breakPriority != gfxBreakPriority::eNoBreak) {
+        gfxBreakPriority lastBreakPriority =
+          baseReflowInput.mLineLayout->LastOptionalBreakPriority();
+        if (breakPriority >= lastBreakPriority) {
+          // Either we have been overflow, or we are forced
+          // to break here, do break before.
+          if (istart > baseReflowInput.AvailableISize() ||
+              baseReflowInput.mLineLayout->NotifyOptionalBreakPosition(
+                aColumn.mBaseFrame, 0, true, breakPriority)) {
+            aStatus = NS_INLINE_LINE_BREAK_BEFORE();
+            return 0;
+          }
+        }
+      }
+    }
+  }
+
+  const uint32_t rtcCount = aReflowInput.mTextContainers.Length();
+  MOZ_ASSERT(aColumn.mTextFrames.Length() == rtcCount);
+  MOZ_ASSERT(textReflowInputs.Length() == rtcCount);
+  nscoord columnISize = 0;
+
+  nsAutoString baseText;
+  if (aColumn.mBaseFrame) {
+    nsLayoutUtils::GetFrameTextContent(aColumn.mBaseFrame, baseText);
+  }
+
+  // Reflow text frames
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    nsRubyTextFrame* textFrame = aColumn.mTextFrames[i];
+    if (textFrame) {
+      nsAutoString annotationText;
+      nsLayoutUtils::GetFrameTextContent(textFrame, annotationText);
+
+      // Per CSS Ruby spec, the content comparison for auto-hiding
+      // takes place prior to white spaces collapsing (white-space)
+      // and text transformation (text-transform), and ignores elements
+      // (considers only the textContent of the boxes). Which means
+      // using the content tree text comparison is correct.
+      if (annotationText.Equals(baseText)) {
+        textFrame->AddStateBits(NS_RUBY_TEXT_FRAME_AUTOHIDE);
+      } else {
+        textFrame->RemoveStateBits(NS_RUBY_TEXT_FRAME_AUTOHIDE);
+      }
+      RubyUtils::ClearReservedISize(textFrame);
+
+      bool pushedFrame;
+      nsReflowStatus reflowStatus;
+      nsLineLayout* lineLayout = textReflowInputs[i]->mLineLayout;
+      nscoord textIStart = lineLayout->GetCurrentICoord();
+      lineLayout->ReflowFrame(textFrame, reflowStatus, nullptr, pushedFrame);
+      if (MOZ_UNLIKELY(NS_INLINE_IS_BREAK(reflowStatus) || pushedFrame)) {
+        MOZ_ASSERT_UNREACHABLE(
+            "Any line break inside ruby box should have been suppressed");
+        // For safety, always drain the overflow list, so that
+        // no frames are left there after reflow.
+        textFrame->DrainSelfOverflowList();
+      }
+      nscoord textISize = lineLayout->GetCurrentICoord() - textIStart;
+      columnISize = std::max(columnISize, textISize);
+    }
+  }
+
+  // Reflow the base frame
+  if (aColumn.mBaseFrame) {
+    RubyUtils::ClearReservedISize(aColumn.mBaseFrame);
+
+    bool pushedFrame;
+    nsReflowStatus reflowStatus;
+    nsLineLayout* lineLayout = baseReflowInput.mLineLayout;
+    nscoord baseIStart = lineLayout->GetCurrentICoord();
+    lineLayout->ReflowFrame(aColumn.mBaseFrame, reflowStatus,
+                            nullptr, pushedFrame);
+    if (MOZ_UNLIKELY(NS_INLINE_IS_BREAK(reflowStatus) || pushedFrame)) {
+      MOZ_ASSERT_UNREACHABLE(
+        "Any line break inside ruby box should have been suppressed");
+      // For safety, always drain the overflow list, so that
+      // no frames are left there after reflow.
+      aColumn.mBaseFrame->DrainSelfOverflowList();
+    }
+    nscoord baseISize = lineLayout->GetCurrentICoord() - baseIStart;
+    columnISize = std::max(columnISize, baseISize);
+  }
+
+  // Align all the line layout to the new coordinate.
+  nscoord icoord = istart + columnISize;
+  nscoord deltaISize = icoord - baseReflowInput.mLineLayout->GetCurrentICoord();
+  if (deltaISize > 0) {
+    baseReflowInput.mLineLayout->AdvanceICoord(deltaISize);
+    if (aColumn.mBaseFrame) {
+      RubyUtils::SetReservedISize(aColumn.mBaseFrame, deltaISize);
+    }
+  }
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    if (aReflowInput.mTextContainers[i]->IsSpanContainer()) {
+      continue;
+    }
+    nsLineLayout* lineLayout = textReflowInputs[i]->mLineLayout;
+    nsRubyTextFrame* textFrame = aColumn.mTextFrames[i];
+    nscoord deltaISize = icoord - lineLayout->GetCurrentICoord();
+    if (deltaISize > 0) {
+      lineLayout->AdvanceICoord(deltaISize);
+      if (textFrame && !textFrame->IsAutoHidden()) {
+        RubyUtils::SetReservedISize(textFrame, deltaISize);
+      }
+    }
+    if (aColumn.mBaseFrame && textFrame) {
+      lineLayout->AttachLastFrameToBaseLineLayout();
+    }
+  }
+
+  return columnISize;
+}
+
+nsRubyBaseContainerFrame::PullFrameState::PullFrameState(
+    nsRubyBaseContainerFrame* aBaseContainer,
+    const AutoRubyTextContainerArray& aTextContainers)
+  : mBase(aBaseContainer)
+  , mTextContainers(aTextContainers)
+{
+  const uint32_t rtcCount = aTextContainers.Length();
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    mTexts.AppendElement(aTextContainers[i]);
+  }
+}
+
+void
+nsRubyBaseContainerFrame::PullOneColumn(nsLineLayout* aLineLayout,
+                                        PullFrameState& aPullFrameState,
+                                        RubyColumn& aColumn,
+                                        bool& aIsComplete)
+{
+  const AutoRubyTextContainerArray& textContainers =
+    aPullFrameState.mTextContainers;
+  const uint32_t rtcCount = textContainers.Length();
+
+  nsIFrame* nextBase = GetNextInFlowChild(aPullFrameState.mBase);
+  MOZ_ASSERT(!nextBase || nextBase->GetType() == nsGkAtoms::rubyBaseFrame);
+  aColumn.mBaseFrame = static_cast<nsRubyBaseFrame*>(nextBase);
+  bool foundFrame = !!aColumn.mBaseFrame;
+  bool pullingIntraLevelWhitespace =
+    aColumn.mBaseFrame && aColumn.mBaseFrame->IsIntraLevelWhitespace();
+
+  aColumn.mTextFrames.ClearAndRetainStorage();
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    nsIFrame* nextText =
+      textContainers[i]->GetNextInFlowChild(aPullFrameState.mTexts[i]);
+    MOZ_ASSERT(!nextText || nextText->GetType() == nsGkAtoms::rubyTextFrame);
+    nsRubyTextFrame* textFrame = static_cast<nsRubyTextFrame*>(nextText);
+    aColumn.mTextFrames.AppendElement(textFrame);
+    foundFrame = foundFrame || nextText;
+    if (nextText && !pullingIntraLevelWhitespace) {
+      pullingIntraLevelWhitespace = textFrame->IsIntraLevelWhitespace();
+    }
+  }
+  // If there exists any frame in continations, we haven't
+  // completed the reflow process.
+  aIsComplete = !foundFrame;
+  if (!foundFrame) {
+    return;
+  }
+
+  aColumn.mIsIntraLevelWhitespace = pullingIntraLevelWhitespace;
+  if (pullingIntraLevelWhitespace) {
+    // We are pulling an intra-level whitespace. Drop all frames which
+    // are not part of this intra-level whitespace column. (Those frames
+    // are really part of the *next* column, after the pulled one.)
+    if (aColumn.mBaseFrame && !aColumn.mBaseFrame->IsIntraLevelWhitespace()) {
+      aColumn.mBaseFrame = nullptr;
+    }
+    for (uint32_t i = 0; i < rtcCount; i++) {
+      nsRubyTextFrame*& textFrame = aColumn.mTextFrames[i];
+      if (textFrame && !textFrame->IsIntraLevelWhitespace()) {
+        textFrame = nullptr;
+      }
+    }
+  } else {
+    // We are not pulling an intra-level whitespace, which means all
+    // elements we are going to pull can have non-whitespace content,
+    // which may contain float which we need to reparent.
+    nsBlockFrame* oldFloatCB = nullptr;
+    for (nsIFrame* frame : aColumn) {
+      oldFloatCB = nsLayoutUtils::GetFloatContainingBlock(frame);
+      break;
+    }
+#ifdef DEBUG
+    MOZ_ASSERT(oldFloatCB, "Must have found a float containing block");
+    for (nsIFrame* frame : aColumn) {
+      MOZ_ASSERT(nsLayoutUtils::GetFloatContainingBlock(frame) == oldFloatCB,
+                 "All frames in the same ruby column should share "
+                 "the same old float containing block");
+    }
+#endif
+    nsBlockFrame* newFloatCB =
+      nsLayoutUtils::GetAsBlock(aLineLayout->LineContainerFrame());
+    MOZ_ASSERT(newFloatCB, "Must have a float containing block");
+    if (oldFloatCB != newFloatCB) {
+      for (nsIFrame* frame : aColumn) {
+        newFloatCB->ReparentFloats(frame, oldFloatCB, false);
+      }
+    }
+  }
+
+  // Pull the frames of this column.
+  if (aColumn.mBaseFrame) {
+    DebugOnly<nsIFrame*> pulled = PullNextInFlowChild(aPullFrameState.mBase);
+    MOZ_ASSERT(pulled == aColumn.mBaseFrame, "pulled a wrong frame?");
+  }
+  for (uint32_t i = 0; i < rtcCount; i++) {
+    if (aColumn.mTextFrames[i]) {
+      DebugOnly<nsIFrame*> pulled =
+        textContainers[i]->PullNextInFlowChild(aPullFrameState.mTexts[i]);
+      MOZ_ASSERT(pulled == aColumn.mTextFrames[i], "pulled a wrong frame?");
+    }
+  }
+
+  if (!aIsComplete) {
+    // We pulled frames from the next line, hence mark it dirty.
+    aLineLayout->SetDirtyNextLine();
+  }
+}
+
+nscoord
+nsRubyBaseContainerFrame::ReflowSpans(const RubyReflowInput& aReflowInput)
+{
+  nscoord spanISize = 0;
+  for (uint32_t i = 0, iend = aReflowInput.mTextContainers.Length();
+       i < iend; i++) {
+    nsRubyTextContainerFrame* container = aReflowInput.mTextContainers[i];
+    if (!container->IsSpanContainer()) {
+      continue;
+    }
+
+    nsIFrame* rtFrame = container->PrincipalChildList().FirstChild();
+    nsReflowStatus reflowStatus;
+    bool pushedFrame;
+    nsLineLayout* lineLayout = aReflowInput.mTextReflowInputs[i]->mLineLayout;
+    MOZ_ASSERT(lineLayout->GetCurrentICoord() == 0,
+               "border/padding of rtc should have been suppressed");
+    lineLayout->ReflowFrame(rtFrame, reflowStatus, nullptr, pushedFrame);
+    MOZ_ASSERT(!NS_INLINE_IS_BREAK(reflowStatus) && !pushedFrame,
+               "Any line break inside ruby box should has been suppressed");
+    spanISize = std::max(spanISize, lineLayout->GetCurrentICoord());
+  }
+  return spanISize;
+}