Bug 488725: Don't position floats in a nowrap context until hitting a break opportunity. r=dbaron
authorEmilio Cobos Álvarez <emilio@crisal.io>
Tue, 21 Aug 2018 16:16:50 +0200
changeset 490813 a4eef4b8a3b0c8560d548ebf0a5ef2f2e17cbb23
parent 490812 ed8e57ba1b07cced1517a62573617ff3cac0fab9
child 490814 731639f445e74ce3d7517d0cae46709d9af659ac
push id1815
push userffxbld-merge
push dateMon, 15 Oct 2018 10:40:45 +0000
treeherdermozilla-release@18d4c09e9378 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdbaron
bugs488725
milestone63.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 488725: Don't position floats in a nowrap context until hitting a break opportunity. r=dbaron Differential Revision: https://phabricator.services.mozilla.com/D3900
layout/generic/BlockReflowInput.h
layout/generic/nsBlockFrame.cpp
layout/generic/nsLineLayout.cpp
layout/generic/nsLineLayout.h
layout/reftests/bugs/reftest.list
layout/reftests/css-grid/grid-container-baselines-003-ref.html
layout/reftests/floats/float-nowrap-1-notref.html
layout/reftests/floats/float-nowrap-1.html
layout/reftests/floats/float-nowrap-2.html
layout/reftests/floats/float-nowrap-3-ref.html
layout/reftests/floats/float-nowrap-3.html
layout/reftests/floats/float-nowrap-4-ref.html
layout/reftests/floats/float-nowrap-4.html
layout/reftests/floats/float-nowrap-5-ref.html
layout/reftests/floats/float-nowrap-5.html
layout/reftests/floats/float-nowrap-6.html
layout/reftests/floats/float-nowrap-7.html
layout/reftests/floats/float-nowrap-8.html
layout/reftests/floats/float-nowrap-9.html
layout/reftests/floats/reftest.list
testing/web-platform/meta/css/css-text/line-breaking/line-breaking-012.html.ini
--- a/layout/generic/BlockReflowInput.h
+++ b/layout/generic/BlockReflowInput.h
@@ -377,16 +377,20 @@ public:
   nsFloatCacheFreeList mCurrentLineFloats;
 
   // The list of floats which are "below current-line"
   // floats. These are reflowed/placed after the line is reflowed
   // and placed. Again, this is done to keep the list fiddling from
   // being N^2.
   nsFloatCacheFreeList mBelowCurrentLineFloats;
 
+  // The list of floats that are waiting on a break opportunity in order to be
+  // placed, since we're on a nowrap context.
+  nsTArray<nsIFrame*> mNoWrapFloats;
+
   nscoord mMinLineHeight;
 
   int32_t mLineNumber;
 
   Flags mFlags;
 
   StyleClear mFloatBreakType;
 
--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -3966,16 +3966,17 @@ nsBlockFrame::ReflowInlineFrames(BlockRe
               lineLayout.GetLastOptionalBreakPosition(&forceBreakOffset, &forceBreakPriority);
           } else {
             forceBreakInFrame = nullptr;
           }
           // restore the float manager state
           aState.FloatManager()->PopState(&floatManagerState);
           // Clear out float lists
           aState.mCurrentLineFloats.DeleteAll();
+          MOZ_ASSERT(aState.mNoWrapFloats.IsEmpty());
           aState.mBelowCurrentLineFloats.DeleteAll();
         }
 
         // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
         allowPullUp = false;
       } while (LineReflowStatus::RedoNoPull == lineReflowStatus);
     } while (LineReflowStatus::RedoMoreFloats == lineReflowStatus);
   } while (LineReflowStatus::RedoNextBand == lineReflowStatus);
@@ -4591,16 +4592,19 @@ bool
 nsBlockFrame::PlaceLine(BlockReflowInput& aState,
                         nsLineLayout& aLineLayout,
                         LineIterator aLine,
                         nsFloatManager::SavedState *aFloatStateBeforeLine,
                         nsFlowAreaRect& aFlowArea,
                         nscoord& aAvailableSpaceBSize,
                         bool* aKeepReflowGoing)
 {
+  // Try to position the floats in a nowrap context.
+  aLineLayout.FlushNoWrapFloats();
+
   // Trim extra white-space from the line before placing the frames
   aLineLayout.TrimTrailingWhiteSpace();
 
   // Vertically align the frames on this line.
   //
   // According to the CSS2 spec, section 12.6.1, the "marker" box
   // participates in the height calculation of the list-item box's
   // first line box.
--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -259,16 +259,17 @@ nsLineLayout::EndLineReflow()
   nsFrame::ListTag(stdout, mBlockReflowInput->mFrame);
   printf(": EndLineReflow: width=%d\n", mRootSpan->mICoord - mRootSpan->mIStart);
 #endif
 
   NS_ASSERTION(!mBaseLineLayout ||
                (!mSpansAllocated && !mSpansFreed && !mSpanFreeList &&
                 !mFramesAllocated && !mFramesFreed && !mFrameFreeList),
                "Allocated frames or spans on non-base line layout?");
+  MOZ_ASSERT(mRootSpan == mCurrentSpan);
 
   UnlinkFrame(mRootSpan->mFrame);
   mCurrentSpan = mRootSpan = nullptr;
 
   NS_ASSERTION(mSpansAllocated == mSpansFreed, "leak");
   NS_ASSERTION(mFramesAllocated == mFramesFreed, "leak");
 
 #if 0
@@ -452,16 +453,22 @@ nsLineLayout::EndSpan(nsIFrame* aFrame)
 {
   NS_ASSERTION(mSpanDepth > 0, "end-span without begin-span");
 #ifdef NOISY_REFLOW
   nsFrame::IndentBy(stdout, mSpanDepth);
   nsFrame::ListTag(stdout, aFrame);
   printf(": EndSpan width=%d\n", mCurrentSpan->mICoord - mCurrentSpan->mIStart);
 #endif
   PerSpanData* psd = mCurrentSpan;
+  MOZ_ASSERT(psd->mParent, "We never call this on the root");
+
+  if (psd->mNoWrap && !psd->mParent->mNoWrap) {
+    FlushNoWrapFloats();
+  }
+
   nscoord iSizeResult = psd->mLastFrame ? (psd->mICoord - psd->mIStart) : 0;
 
   mSpanDepth--;
   mCurrentSpan->mReflowInput = nullptr;  // no longer valid so null it out!
   mCurrentSpan = mCurrentSpan->mParent;
   return iSizeResult;
 }
 
@@ -949,37 +956,24 @@ nsLineLayout::ReflowFrame(nsIFrame* aFra
     isEmpty = pfd->mFrame->IsEmpty();
   } else {
     if (LayoutFrameType::Placeholder == frameType) {
       isEmpty = true;
       pfd->mIsPlaceholder = true;
       pfd->mSkipWhenTrimmingWhitespace = true;
       nsIFrame* outOfFlowFrame = nsLayoutUtils::GetFloatFromPlaceholder(aFrame);
       if (outOfFlowFrame) {
-        // Add mTrimmableISize to the available width since if the line ends
-        // here, the width of the inline content will be reduced by
-        // mTrimmableISize.
-        nscoord availableISize = psd->mIEnd - (psd->mICoord - mTrimmableISize);
-        if (psd->mNoWrap) {
-          // If we place floats after inline content where there's
-          // no break opportunity, we don't know how much additional
-          // width is required for the non-breaking content after the float,
-          // so we can't know whether the float plus that content will fit
-          // on the line. So for now, don't place floats after inline
-          // content where there's no break opportunity. This is incorrect
-          // but hopefully rare. Fixing it will require significant
-          // restructuring of line layout.
-          // We might as well allow zero-width floats to be placed, though.
-          availableISize = 0;
+        if (psd->mNoWrap &&
+            !LineIsEmpty() && // We can always place floats in an empty line.
+            !GetOutermostLineLayout()->mBlockRI->mFlags.mCanHaveTextOverflow) {
+          // We'll do this at the next break opportunity.
+          RecordNoWrapFloat(outOfFlowFrame);
+        } else {
+          placedFloat = TryToPlaceFloat(outOfFlowFrame);
         }
-        placedFloat = GetOutermostLineLayout()->
-          AddFloat(outOfFlowFrame, availableISize);
-        NS_ASSERTION(!(outOfFlowFrame->IsLetterFrame() &&
-                       GetFirstLetterStyleOK()),
-                    "FirstLetterStyle set on line with floating first letter");
       }
     }
     else if (isText) {
       // Note non-empty text-frames for inline frame compatibility hackery
       pfd->mIsTextFrame = true;
       nsTextFrame* textFrame = static_cast<nsTextFrame*>(pfd->mFrame);
       isEmpty = !textFrame->HasNoncollapsedCharacters();
       if (!isEmpty) {
@@ -1114,18 +1108,18 @@ nsLineLayout::ReflowFrame(nsIFrame* aFra
       PerSpanData* span = pfd->mSpan;
       if (span) {
         // The frame we just finished reflowing is an inline
         // container.  It needs its child frames aligned in the block direction,
         // so do most of it now.
         VerticalAlignFrames(span);
       }
 
-      if (!continuingTextRun) {
-        if (!psd->mNoWrap && (!LineIsEmpty() || placedFloat)) {
+      if (!continuingTextRun && !psd->mNoWrap) {
+        if (!LineIsEmpty() || placedFloat) {
           // record soft break opportunity after this content that can't be
           // part of a text run. This is not a text frame so we know
           // that offset INT32_MAX means "after the content".
           if (NotifyOptionalBreakPosition(aFrame, INT32_MAX,
                                           optionalBreakAfterFits,
                                           gfxBreakPriority::eNormalBreak)) {
             // If this returns true then we are being told to actually break here.
             aReflowStatus.SetInlineLineBreakAfter();
@@ -1500,16 +1494,70 @@ nsLineLayout::DumpPerSpanData(PerSpanDat
     if (pfd->mSpan) {
       DumpPerSpanData(pfd->mSpan, aIndent + 1);
     }
     pfd = pfd->mNext;
   }
 }
 #endif
 
+void
+nsLineLayout::RecordNoWrapFloat(nsIFrame* aFloat)
+{
+  GetOutermostLineLayout()->mBlockRI->mNoWrapFloats.AppendElement(aFloat);
+}
+
+void
+nsLineLayout::FlushNoWrapFloats()
+{
+  auto& noWrapFloats = GetOutermostLineLayout()->mBlockRI->mNoWrapFloats;
+  for (nsIFrame* floatedFrame : noWrapFloats) {
+    TryToPlaceFloat(floatedFrame);
+  }
+  noWrapFloats.Clear();
+}
+
+bool
+nsLineLayout::TryToPlaceFloat(nsIFrame* aFloat)
+{
+  // Add mTrimmableISize to the available width since if the line ends here, the
+  // width of the inline content will be reduced by mTrimmableISize.
+  nscoord availableISize = mCurrentSpan->mIEnd - (mCurrentSpan->mICoord - mTrimmableISize);
+  NS_ASSERTION(!(aFloat->IsLetterFrame() && GetFirstLetterStyleOK()),
+              "FirstLetterStyle set on line with floating first letter");
+  return GetOutermostLineLayout()->AddFloat(aFloat, availableISize);
+}
+
+bool
+nsLineLayout::NotifyOptionalBreakPosition(nsIFrame* aFrame,
+                                          int32_t aOffset,
+                                          bool aFits,
+                                          gfxBreakPriority aPriority)
+{
+  MOZ_ASSERT(!aFits || !mNeedBackup,
+             "Shouldn't be updating the break position with a break that fits "
+             "after we've already flagged an overrun");
+  MOZ_ASSERT(mCurrentSpan, "Should be doing line layout");
+  if (mCurrentSpan->mNoWrap) {
+    FlushNoWrapFloats();
+  }
+
+  // Remember the last break position that fits; if there was no break that fit,
+  // just remember the first break
+  if ((aFits && aPriority >= mLastOptionalBreakPriority) ||
+      !mLastOptionalBreakFrame) {
+    mLastOptionalBreakFrame = aFrame;
+    mLastOptionalBreakFrameOffset = aOffset;
+    mLastOptionalBreakPriority = aPriority;
+  }
+  return aFrame && mForceBreakFrame == aFrame &&
+    mForceBreakFrameOffset == aOffset;
+}
+
+
 #define VALIGN_OTHER  0
 #define VALIGN_TOP    1
 #define VALIGN_BOTTOM 2
 
 void
 nsLineLayout::VerticalAlignLine()
 {
   // Partially place the children of the block frame. The baseline for
--- a/layout/generic/nsLineLayout.h
+++ b/layout/generic/nsLineLayout.h
@@ -246,31 +246,31 @@ public:
    *
    * @param aPriority the priority of the break opportunity. If we are
    * prioritizing break opportunities, we will not set a break if we have
    * already set a break with a higher priority. @see gfxBreakPriority.
    *
    * @return true if we are actually reflowing with forced break position and we
    * should break here
    */
-  bool NotifyOptionalBreakPosition(nsIFrame* aFrame, int32_t aOffset,
-                                   bool aFits, gfxBreakPriority aPriority) {
-    NS_ASSERTION(!aFits || !mNeedBackup,
-                  "Shouldn't be updating the break position with a break that fits after we've already flagged an overrun");
-    // Remember the last break position that fits; if there was no break that fit,
-    // just remember the first break
-    if ((aFits && aPriority >= mLastOptionalBreakPriority) ||
-        !mLastOptionalBreakFrame) {
-      mLastOptionalBreakFrame = aFrame;
-      mLastOptionalBreakFrameOffset = aOffset;
-      mLastOptionalBreakPriority = aPriority;
-    }
-    return aFrame && mForceBreakFrame == aFrame &&
-      mForceBreakFrameOffset == aOffset;
-  }
+  bool NotifyOptionalBreakPosition(nsIFrame* aFrame,
+                                   int32_t aOffset,
+                                   bool aFits,
+                                   gfxBreakPriority aPriority);
+
+  // Tries to place a float, and records whether the float actually was placed.
+  bool TryToPlaceFloat(nsIFrame* aFloat);
+
+  // Records a floating frame in a nowrap context for it to be placed on the
+  // next break opportunity.
+  void RecordNoWrapFloat(nsIFrame* aFloat);
+
+  // Tries to place the floats from the nowrap context.
+  void FlushNoWrapFloats();
+
   /**
    * Like NotifyOptionalBreakPosition, but here it's OK for mNeedBackup
    * to be set, because the caller is merely pruning some saved break position(s)
    * that are actually not feasible.
    */
   void RestoreSavedBreakPosition(nsIFrame* aFrame, int32_t aOffset,
                                  gfxBreakPriority aPriority) {
     mLastOptionalBreakFrame = aFrame;
--- a/layout/reftests/bugs/reftest.list
+++ b/layout/reftests/bugs/reftest.list
@@ -1146,17 +1146,17 @@ fuzzy-if(skiaContent,0-1,0-3280) == 4389
 fuzzy-if(skiaContent,0-1,0-3280) == 438987-2c.html 438987-2-ref.html
 != about:blank 438987-2-ref.html # check that backgrounds work at all
 == 439004-1.html 439004-1-ref.html
 == 439639-1.html 439639-1-ref.html
 == 439910.html 439910-ref.html
 fuzzy-if(skiaContent,0-1,0-1) == 440112.html 440112-ref.html
 == 440149-1.html 440149-1-ref.html
 == 441259-1.html 441259-1-ref.html
-fails == 441259-2.html 441259-2-ref.html # bug 441400
+== 441259-2.html 441259-2-ref.html
 fuzzy-if(skiaContent,0-1,0-3) == 442542-1.html 442542-1-ref.html
 == 444015-1.html 444015-1-ref.html
 == 444375-1.html 444375-1-ref.html
 == 444928-1.html 444928-1-ref.html
 == 444928-2.html 444928-2-ref.html
 != 444928-3.html 444928-3-notref.html
 random == 445004-1.html 445004-1-ref.html # bug 472268
 == 445142-1a.html 445142-1-ref.html
--- a/layout/reftests/css-grid/grid-container-baselines-003-ref.html
+++ b/layout/reftests/css-grid/grid-container-baselines-003-ref.html
@@ -82,17 +82,17 @@ A<div class="ib">
   </div><span class="i a f" style="width:54px">C<br>D</span><span
      class="a f" style="width:54px; padding-top:20px">E<br>F</span>
 </div>
 
 
 <div class="ib" style="width:200px;">
   <div class="ib" style="height:120px; width:76px; white-space:nowrap"><span
      class="a f" style="width:30px; margin-top:7px; padding-top:5px; padding-bottom:18px;">A<br>B</span><span
-     class="a f" style="float:right; width:30px; position:relative; left:-4px; padding-bottom:22px; margin-top:-100px">A<br>B</span>
+     class="a f" style="float:right; width:30px; position:relative; left:-4px; padding-bottom:22px;">A<br>B</span>
   </div><span class="i a f" style="width:54px">C<br>D</span><span
      class="a f" style="width:54px; padding-top:20px;">E<br>F</span>
 </div>
 
 <br>
 
 <x style="position:relative; top:-64px">A</x><div class="ib" style="width:200px;margin-top:32px">
   <div class="ib vl" style="height:70px; width:196px;">
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-1-notref.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    white-space: nowrap;
+    font-family: monospace;
+  }
+  span {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+</style>
+<div>
+  <span></span>
+  Some text that overflows my parent.
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-1.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    white-space: nowrap;
+    font-family: monospace;
+  }
+  span {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+</style>
+<div>
+  Some text that overflows my parent.
+  <span></span>
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-2.html
@@ -0,0 +1,19 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    white-space: nowrap;
+    font-family: monospace;
+  }
+  span {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+</style>
+<div>
+  Some text that
+  <span></span>
+  overflows my parent.
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-3-ref.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    font-family: monospace;
+  }
+  .float {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+  .nowrap {
+    white-space: nowrap;
+  }
+</style>
+<div>
+  Some
+  <span class="nowrap">
+    text that overflows my parent.
+  </span>
+  <span class="float"></span>
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-3.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    font-family: monospace;
+  }
+  .float {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+  .nowrap {
+    white-space: nowrap;
+  }
+</style>
+<div>
+  Some
+  <span class="nowrap">
+    text that overflows <span class="float"></span> my parent.
+  </span>
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-4-ref.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    font-family: monospace;
+  }
+  .float {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+  .nowrap {
+    white-space: nowrap;
+  }
+</style>
+<div>
+  Some
+  <span class="float"></span>
+  <span class="nowrap">
+    text that overflows my parent.
+  </span>
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-4.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    font-family: monospace;
+  }
+  .float {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+  .nowrap {
+    white-space: nowrap;
+  }
+</style>
+<div>
+  Some
+  <span class="nowrap">
+    <span class="float"></span> text that overflows my parent.
+  </span>
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-5-ref.html
@@ -0,0 +1,2 @@
+<!doctype html>
+<div>Hello Kittie
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-5.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<style>
+  div {
+    white-space: nowrap;
+  }
+  span {
+    float: left;
+  }
+</style>
+<div>Kittie<span>Hello&nbsp;</span>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-6.html
@@ -0,0 +1,10 @@
+<!doctype html>
+<style>
+  div {
+    white-space: nowrap;
+  }
+  span {
+    float: left;
+  }
+</style>
+<div><span>Hello&nbsp;</span>Kittie
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-7.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    white-space: nowrap;
+    font-family: monospace;
+  }
+  .nowrap {
+    white-space: nowrap;
+  }
+  .float {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+</style>
+<div>
+  <span class="nowrap">S<div class="float"></div><span>ome</span> text that overflows my parent.</span>
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-8.html
@@ -0,0 +1,18 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    white-space: nowrap;
+    font-family: monospace;
+  }
+  span {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+</style>
+<div>
+  Some <span></span>
+  text that overflows my parent.
+</div>
new file mode 100644
--- /dev/null
+++ b/layout/reftests/floats/float-nowrap-9.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<style>
+  div {
+    width: 10ch;
+    font-family: monospace;
+  }
+  .float {
+    float: right;
+    width: 5ch;
+    height: 5ch;
+    background: blue;
+  }
+  .nowrap {
+    white-space: nowrap;
+  }
+</style>
+<div>
+  Some
+  <span class="nowrap">
+    text <span class="float"></span> that overflows my parent.
+  </span>
+</div>
--- a/layout/reftests/floats/reftest.list
+++ b/layout/reftests/floats/reftest.list
@@ -112,8 +112,18 @@ random-if(/^Windows\x20NT\x206\.1/.test(
 == float-in-rtl-slr-3a.html float-in-rtl-slr-3-ref.html
 == float-in-rtl-slr-3b.html float-in-rtl-slr-3-ref.html
 == float-in-rtl-slr-3c.html float-in-rtl-slr-3-ref.html
 == float-in-rtl-slr-3d.html float-in-rtl-slr-3-ref.html
 == float-in-rtl-slr-4a.html float-in-rtl-slr-4-ref.html
 == float-in-rtl-slr-4b.html float-in-rtl-slr-4-ref.html
 == float-in-rtl-slr-4c.html float-in-rtl-slr-4-ref.html
 == float-in-rtl-slr-4d.html float-in-rtl-slr-4-ref.html
+!= float-nowrap-1.html float-nowrap-1-notref.html
+== float-nowrap-2.html float-nowrap-1.html
+== float-nowrap-3.html float-nowrap-3-ref.html
+!= float-nowrap-3.html float-nowrap-4.html
+== float-nowrap-4.html float-nowrap-4-ref.html
+== float-nowrap-5.html float-nowrap-5-ref.html
+== float-nowrap-6.html float-nowrap-5-ref.html
+== float-nowrap-7.html float-nowrap-1.html
+== float-nowrap-8.html float-nowrap-1.html
+== float-nowrap-9.html float-nowrap-3-ref.html
deleted file mode 100644
--- a/testing/web-platform/meta/css/css-text/line-breaking/line-breaking-012.html.ini
+++ /dev/null
@@ -1,2 +0,0 @@
-[line-breaking-012.html]
-  expected: FAIL