Bug 1183431 - Ensure hypothetical box has a writing mode with the same block direction as the absolute containing block. r=dholbert
authorJonathan Kew <jkew@mozilla.com>
Thu, 06 Aug 2015 21:01:31 +0100
changeset 288345 2debc63507da51f9f884a0e6e7c3bd9bac254dc3
parent 288344 b1f46ed83467c00cbd7b8f1a2bcee1e67df5da6e
child 288346 bb8a643c7096e23c0356f0e7a2f1e9a65ffac45e
push id5067
push userraliiev@mozilla.com
push dateMon, 21 Sep 2015 14:04:52 +0000
treeherdermozilla-beta@14221ffe5b2f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdholbert
bugs1183431
milestone42.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 1183431 - Ensure hypothetical box has a writing mode with the same block direction as the absolute containing block. r=dholbert
layout/generic/crashtests/crashtests.list
layout/generic/nsHTMLReflowState.cpp
layout/generic/nsHTMLReflowState.h
layout/reftests/writing-mode/abspos/reftest.list
--- a/layout/generic/crashtests/crashtests.list
+++ b/layout/generic/crashtests/crashtests.list
@@ -582,9 +582,9 @@ asserts(0-3) load 1134667.html
 asserts(0-3) load 1134667.html
 load 1146103.html
 load 1146107.html
 load 1146114.html
 load 1156222.html
 load 1157011.html
 load 1169420-1.html
 load 1169420-2.html
-asserts(1) load 1183431.html
+load 1183431.html
--- a/layout/generic/nsHTMLReflowState.cpp
+++ b/layout/generic/nsHTMLReflowState.cpp
@@ -990,19 +990,19 @@ nsHTMLReflowState::ApplyRelativePosition
       StickyScrollContainer::GetStickyScrollContainerForFrame(aFrame);
     if (ssc) {
       *aPosition = ssc->ComputePosition(aFrame);
     }
   }
 }
 
 nsIFrame*
-nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame* aFrame,
-                                               nscoord& aCBIStartEdge,
-                                               nscoord& aCBISize)
+nsHTMLReflowState::GetHypotheticalBoxContainer(nsIFrame*    aFrame,
+                                               nscoord&     aCBIStartEdge,
+                                               LogicalSize& aCBSize)
 {
   aFrame = aFrame->GetContainingBlock();
   NS_ASSERTION(aFrame != frame, "How did that happen?");
 
   /* Now aFrame is the containing block we want */
 
   /* Check whether the containing block is currently being reflowed.
      If so, use the info from the reflow state. */
@@ -1016,26 +1016,26 @@ nsHTMLReflowState::GetHypotheticalBoxCon
     state = nullptr;
   }
 
   WritingMode wm = aFrame->GetWritingMode();
   if (state) {
     WritingMode stateWM = state->GetWritingMode();
     aCBIStartEdge =
       state->ComputedLogicalBorderPadding().ConvertTo(wm, stateWM).IStart(wm);
-    aCBISize = state->ComputedSize(wm).ISize(wm);
+    aCBSize = state->ComputedSize(wm);
   } else {
     /* Didn't find a reflow state for aFrame.  Just compute the information we
        want, on the assumption that aFrame already knows its size.  This really
        ought to be true by now. */
     NS_ASSERTION(!(aFrame->GetStateBits() & NS_FRAME_IN_REFLOW),
                  "aFrame shouldn't be in reflow; we'll lie if it is");
     LogicalMargin borderPadding = aFrame->GetLogicalUsedBorderAndPadding(wm);
     aCBIStartEdge = borderPadding.IStart(wm);
-    aCBISize = aFrame->ISize(wm) - borderPadding.IStartEnd(wm);
+    aCBSize = aFrame->GetLogicalSize(wm) - borderPadding.Size(wm);
   }
 
   return aFrame;
 }
 
 // When determining the hypothetical box that would have been if the element
 // had been in the flow we may not be able to exactly determine both the IStart
 // and IEnd edges. For example, if the element is a non-replaced inline-level
@@ -1075,81 +1075,91 @@ GetIntrinsicSizeFor(nsIFrame* aFrame, ns
     if (NS_SUCCEEDED(imageFrame->GetIntrinsicImageSize(aIntrinsicSize))) {
       success = (aIntrinsicSize != nsSize(0, 0));
     }
   }
   return success;
 }
 
 /**
- * aInsideBoxSizing returns the part of the horizontal padding, border,
- * and margin that goes inside the edge given by box-sizing;
+ * aInsideBoxSizing returns the part of the padding, border, and margin
+ * in the aAxis dimension that goes inside the edge given by box-sizing;
  * aOutsideBoxSizing returns the rest.
  */
 void
-nsHTMLReflowState::CalculateInlineBorderPaddingMargin(
-                       nscoord aContainingBlockISize,
+nsHTMLReflowState::CalculateBorderPaddingMargin(
+                       LogicalAxis aAxis,
+                       nscoord aContainingBlockSize,
                        nscoord* aInsideBoxSizing,
                        nscoord* aOutsideBoxSizing)
 {
   WritingMode wm = GetWritingMode();
-  mozilla::css::Side inlineStart = wm.PhysicalSide(eLogicalSideIStart);
-  mozilla::css::Side inlineEnd   = wm.PhysicalSide(eLogicalSideIEnd);
+  mozilla::css::Side startSide =
+    wm.PhysicalSide(MakeLogicalSide(aAxis, eLogicalEdgeStart));
+  mozilla::css::Side endSide =
+    wm.PhysicalSide(MakeLogicalSide(aAxis, eLogicalEdgeEnd));
 
-  const LogicalMargin& border =
-    LogicalMargin(wm, mStyleBorder->GetComputedBorder());
-  LogicalMargin padding(wm), margin(wm);
+  nsMargin styleBorder = mStyleBorder->GetComputedBorder();
+  nscoord borderStartEnd =
+    styleBorder.Side(startSide) + styleBorder.Side(endSide);
+
+  nscoord paddingStartEnd, marginStartEnd;
 
   // See if the style system can provide us the padding directly
   nsMargin stylePadding;
   if (mStylePadding->GetPadding(stylePadding)) {
-    padding = LogicalMargin(wm, stylePadding);
+    paddingStartEnd =
+      stylePadding.Side(startSide) + stylePadding.Side(endSide);
   } else {
-    // We have to compute the inline start and end values
-    padding.IStart(wm) = nsLayoutUtils::
-      ComputeCBDependentValue(aContainingBlockISize,
-                              mStylePadding->mPadding.Get(inlineStart));
-    padding.IEnd(wm) = nsLayoutUtils::
-      ComputeCBDependentValue(aContainingBlockISize,
-                              mStylePadding->mPadding.Get(inlineEnd));
+    // We have to compute the start and end values
+    nscoord start, end;
+    start = nsLayoutUtils::
+      ComputeCBDependentValue(aContainingBlockSize,
+                              mStylePadding->mPadding.Get(startSide));
+    end = nsLayoutUtils::
+      ComputeCBDependentValue(aContainingBlockSize,
+                              mStylePadding->mPadding.Get(endSide));
+    paddingStartEnd = start + end;
   }
 
   // See if the style system can provide us the margin directly
   nsMargin styleMargin;
   if (mStyleMargin->GetMargin(styleMargin)) {
-    margin = LogicalMargin(wm, styleMargin);
+    marginStartEnd =
+      styleMargin.Side(startSide) + styleMargin.Side(endSide);
   } else {
-    // We have to compute the left and right values
-    if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(inlineStart)) {
+    nscoord start, end;
+    // We have to compute the start and end values
+    if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(startSide)) {
       // XXX FIXME (or does CalculateBlockSideMargins do this?)
-      margin.IStart(wm) = 0;  // just ignore
+      start = 0;  // just ignore
     } else {
-      margin.IStart(wm) = nsLayoutUtils::
-        ComputeCBDependentValue(aContainingBlockISize,
-                                mStyleMargin->mMargin.Get(inlineStart));
+      start = nsLayoutUtils::
+        ComputeCBDependentValue(aContainingBlockSize,
+                                mStyleMargin->mMargin.Get(startSide));
     }
-    if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(inlineEnd)) {
+    if (eStyleUnit_Auto == mStyleMargin->mMargin.GetUnit(endSide)) {
       // XXX FIXME (or does CalculateBlockSideMargins do this?)
-      margin.IEnd(wm) = 0;  // just ignore
+      end = 0;  // just ignore
     } else {
-      margin.IEnd(wm) = nsLayoutUtils::
-        ComputeCBDependentValue(aContainingBlockISize,
-                                mStyleMargin->mMargin.Get(inlineEnd));
+      end = nsLayoutUtils::
+        ComputeCBDependentValue(aContainingBlockSize,
+                                mStyleMargin->mMargin.Get(endSide));
     }
+    marginStartEnd = start + end;
   }
 
-  nscoord outside =
-    padding.IStartEnd(wm) + border.IStartEnd(wm) + margin.IStartEnd(wm);
+  nscoord outside = paddingStartEnd + borderStartEnd + marginStartEnd;
   nscoord inside = 0;
   switch (mStylePosition->mBoxSizing) {
     case NS_STYLE_BOX_SIZING_BORDER:
-      inside += border.IStartEnd(wm);
+      inside += borderStartEnd;
       // fall through
     case NS_STYLE_BOX_SIZING_PADDING:
-      inside += padding.IStartEnd(wm);
+      inside += paddingStartEnd;
   }
   outside -= inside;
   *aInsideBoxSizing = inside;
   *aOutsideBoxSizing = outside;
   return;
 }
 
 /**
@@ -1173,40 +1183,48 @@ static bool AreAllEarlierInFlowFramesEmp
     }
   }
   *aFound = false;
   return true;
 }
 
 // Calculate the hypothetical box that the element would have if it were in
 // the flow. The values returned are relative to the padding edge of the
-// absolute containing block, in the actual containing block's writing mode.
-// cbrs->frame is the actual containing block
+// absolute containing block. The writing-mode of the hypothetical box will
+// have the same block direction as the absolute containing block, but may
+// differ in inline-bidi direction.
+// In the code below, |cbrs->frame| is the absolute containing block, while
+// |containingBlock| is the nearest block container of the placeholder frame,
+// which may be different from the absolute containing block.
 void
 nsHTMLReflowState::CalculateHypotheticalBox(nsPresContext*    aPresContext,
                                             nsIFrame*         aPlaceholderFrame,
                                             const nsHTMLReflowState* cbrs,
                                             nsHypotheticalBox& aHypotheticalBox,
                                             nsIAtom*          aFrameType)
 {
   NS_ASSERTION(mStyleDisplay->mOriginalDisplay != NS_STYLE_DISPLAY_NONE,
                "mOriginalDisplay has not been properly initialized");
 
   // Find the nearest containing block frame to the placeholder frame,
   // and its inline-start edge and width.
-  nscoord blockIStartContentEdge, blockContentISize;
+  nscoord blockIStartContentEdge;
+  // Dummy writing mode for blockContentSize, will be changed as needed by
+  // GetHypotheticalBoxContainer.
+  WritingMode cbwm = cbrs->GetWritingMode();
+  LogicalSize blockContentSize(cbwm);
   nsIFrame* containingBlock =
     GetHypotheticalBoxContainer(aPlaceholderFrame, blockIStartContentEdge,
-                                blockContentISize);
+                                blockContentSize);
+  // Now blockContentSize is in containingBlock's writing mode.
 
   // If it's a replaced element and it has a 'auto' value for
   //'inline size', see if we can get the intrinsic size. This will allow
   // us to exactly determine both the inline edges
   WritingMode wm = containingBlock->GetWritingMode();
-  aHypotheticalBox.mWritingMode = wm;
 
   nsStyleCoord styleISize = mStylePosition->ISize(wm);
   bool isAutoISize = styleISize.GetUnit() == eStyleUnit_Auto;
   nsSize      intrinsicSize;
   bool        knowIntrinsicSize = false;
   if (NS_FRAME_IS_REPLACED(mFrameType) && isAutoISize) {
     // See if we can get the intrinsic size of the element
     knowIntrinsicSize = GetIntrinsicSizeFor(frame, intrinsicSize, aFrameType);
@@ -1225,50 +1243,50 @@ nsHTMLReflowState::CalculateHypothetical
   } else {
     // It's either a replaced inline-level element or a block-level element
 
     // Determine the total amount of inline direction
     // border/padding/margin that the element would have had if it had
     // been in the flow. Note that we ignore any 'auto' and 'inherit'
     // values
     nscoord insideBoxSizing, outsideBoxSizing;
-    CalculateInlineBorderPaddingMargin(blockContentISize,
-                                       &insideBoxSizing, &outsideBoxSizing);
+    CalculateBorderPaddingMargin(eLogicalAxisInline,
+                                 blockContentSize.ISize(wm),
+                                 &insideBoxSizing, &outsideBoxSizing);
 
     if (NS_FRAME_IS_REPLACED(mFrameType) && isAutoISize) {
       // It's a replaced element with an 'auto' inline size so the box
       // inline size is its intrinsic size plus any border/padding/margin
       if (knowIntrinsicSize) {
         boxISize = LogicalSize(wm, intrinsicSize).ISize(wm) +
                    outsideBoxSizing + insideBoxSizing;
         knowBoxISize = true;
       }
 
     } else if (isAutoISize) {
       // The box inline size is the containing block inline size
-      boxISize = blockContentISize;
+      boxISize = blockContentSize.ISize(wm);
       knowBoxISize = true;
 
     } else {
       // We need to compute it. It's important we do this, because if it's
       // percentage based this computed value may be different from the computed
       // value calculated using the absolute containing block width
-      boxISize = ComputeISizeValue(blockContentISize,
+      boxISize = ComputeISizeValue(blockContentSize.ISize(wm),
                                    insideBoxSizing, outsideBoxSizing,
                                    styleISize) +
                  insideBoxSizing + outsideBoxSizing;
       knowBoxISize = true;
     }
   }
 
   // Get the placeholder x-offset and y-offset in the coordinate
   // space of its containing block
   // XXXbz the placeholder is not fully reflowed yet if our containing block is
   // relatively positioned...
-  WritingMode cbwm = cbrs->GetWritingMode();
   nsSize containerSize = containingBlock->GetStateBits() & NS_FRAME_IN_REFLOW
     ? cbrs->ComputedSizeAsContainerIfConstrained()
     : containingBlock->GetSize();
   LogicalPoint
     placeholderOffset(wm, aPlaceholderFrame->GetOffsetTo(containingBlock),
                       containerSize);
 
   // First, determine the hypothetical box's mBStart.  We want to check the
@@ -1363,17 +1381,18 @@ nsHTMLReflowState::CalculateHypothetical
     aHypotheticalBox.mIEnd = aHypotheticalBox.mIStart + boxISize;
 #ifdef DEBUG
     aHypotheticalBox.mIEndIsExact = true;
 #endif
   } else {
     // We can't compute the inline-end edge because we don't know the desired
     // inline-size. So instead use the end content edge of the block parent,
     // but remember it's not exact
-    aHypotheticalBox.mIEnd = blockIStartContentEdge + blockContentISize;
+    aHypotheticalBox.mIEnd =
+      blockIStartContentEdge + blockContentSize.ISize(wm);
 #ifdef DEBUG
     aHypotheticalBox.mIEndIsExact = false;
 #endif
   }
 
   // The current coordinate space is that of the nearest block to the placeholder.
   // Convert to the coordinate space of the absolute containing block
   // One weird thing here is that for fixed-positioned elements we want to do
@@ -1406,33 +1425,99 @@ nsHTMLReflowState::CalculateHypothetical
     } while (containingBlock != cbrs->frame);
   } else {
     // XXXldb We need to either ignore scrolling for the absolute
     // positioning case too (and take the incompatibility) or figure out
     // how to make these positioned elements actually *move* when we
     // scroll, and thus avoid the resulting incremental reflow bugs.
     cbOffset = containingBlock->GetOffsetTo(cbrs->frame);
   }
-  nsSize cbrsSize =
-    cbrs->ComputedPhysicalSize() +
-    cbrs->ComputedLogicalBorderPadding().Size(cbwm).GetPhysicalSize(cbwm);
+  nsSize cbrsSize = cbrs->ComputedSizeAsContainerIfConstrained();
   LogicalPoint logCBOffs(wm, cbOffset, cbrsSize - containerSize);
   aHypotheticalBox.mIStart += logCBOffs.I(wm);
   aHypotheticalBox.mIEnd += logCBOffs.I(wm);
   aHypotheticalBox.mBStart += logCBOffs.B(wm);
 
   // The specified offsets are relative to the absolute containing block's
   // padding edge and our current values are relative to the border edge, so
   // translate.
   LogicalMargin border =
     cbrs->ComputedLogicalBorderPadding() - cbrs->ComputedLogicalPadding();
   border = border.ConvertTo(wm, cbrs->GetWritingMode());
   aHypotheticalBox.mIStart -= border.IStart(wm);
   aHypotheticalBox.mIEnd -= border.IStart(wm);
   aHypotheticalBox.mBStart -= border.BStart(wm);
+
+  // At this point, we have computed aHypotheticalBox using the writing mode
+  // of the placeholder's containing block.
+
+  if (cbwm.GetBlockDir() != wm.GetBlockDir()) {
+    // If the block direction we used in calculating aHypotheticalBox does not
+    // match the absolute containing block's, we need to convert here so that
+    // aHypotheticalBox is usable in relation to the absolute containing block.
+    // This requires computing or measuring the abspos frame's block-size,
+    // which is not otherwise required/used here (as aHypotheticalBox records
+    // only the block-start coordinate).
+
+    // This is similar to the inline-size calculation for a replaced
+    // inline-level element or a block-level element (above), except that
+    // 'auto' sizing is handled differently in the block direction for non-
+    // replaced elements and replaced elements lacking an intrinsic size.
+
+    // Determine the total amount of block direction
+    // border/padding/margin that the element would have had if it had
+    // been in the flow. Note that we ignore any 'auto' and 'inherit'
+    // values.
+    nscoord insideBoxSizing, outsideBoxSizing;
+    CalculateBorderPaddingMargin(eLogicalAxisBlock,
+                                 blockContentSize.BSize(wm),
+                                 &insideBoxSizing, &outsideBoxSizing);
+
+    nscoord boxBSize;
+    nsStyleCoord styleBSize = mStylePosition->BSize(wm);
+    bool isAutoBSize = styleBSize.GetUnit() == eStyleUnit_Auto;
+    if (isAutoBSize) {
+      if (NS_FRAME_IS_REPLACED(mFrameType) && knowIntrinsicSize) {
+        // It's a replaced element with an 'auto' block size so the box
+        // block size is its intrinsic size plus any border/padding/margin
+        boxBSize = LogicalSize(wm, intrinsicSize).BSize(wm) +
+                   outsideBoxSizing + insideBoxSizing;
+      } else {
+        // XXX Bug 1191801
+        // Figure out how to get the correct boxBSize here (need to reflow the
+        // positioned frame?)
+        boxBSize = 0;
+      }
+    } else {
+      // We need to compute it. It's important we do this, because if it's
+      // percentage-based this computed value may be different from the
+      // computed value calculated using the absolute containing block height.
+      boxBSize = ComputeBSizeValue(blockContentSize.BSize(wm),
+                                   insideBoxSizing, styleBSize) +
+                 insideBoxSizing + outsideBoxSizing;
+    }
+
+    LogicalSize boxSize(wm, knowBoxISize ? boxISize : 0, boxBSize);
+
+    LogicalPoint origin(wm, aHypotheticalBox.mIStart,
+                        aHypotheticalBox.mBStart);
+    origin = origin.ConvertTo(cbwm, wm, cbrsSize -
+                              boxSize.GetPhysicalSize(wm));
+
+    aHypotheticalBox.mIStart = origin.I(cbwm);
+    aHypotheticalBox.mIEnd = aHypotheticalBox.mIStart +
+                             boxSize.ConvertTo(cbwm, wm).ISize(cbwm);
+#ifdef DEBUG
+    aHypotheticalBox.mIEndIsExact = false; // it may be fake
+#endif
+    aHypotheticalBox.mBStart = origin.B(cbwm);
+    aHypotheticalBox.mWritingMode = cbwm;
+  } else {
+    aHypotheticalBox.mWritingMode = wm;
+  }
 }
 
 void
 nsHTMLReflowState::InitAbsoluteConstraints(nsPresContext* aPresContext,
                                            const nsHTMLReflowState* cbrs,
                                            const LogicalSize& aCBSize,
                                            nsIAtom* aFrameType)
 {
@@ -1518,18 +1603,16 @@ nsHTMLReflowState::InitAbsoluteConstrain
   } else {
     offsets.BEnd(cbwm) = nsLayoutUtils::
       ComputeBSizeDependentValue(cbSize.BSize(cbwm),
                                  mStylePosition->mOffset.GetBEnd(cbwm));
   }
 
   if (bStartIsAuto && bEndIsAuto) {
     // Treat 'top' like 'static-position'
-    NS_ASSERTION(hypotheticalBox.mWritingMode.GetBlockDir() == cbwm.GetBlockDir(),
-                 "block direction mismatch");
     offsets.BStart(cbwm) = hypotheticalBox.mBStart;
     bStartIsAuto = false;
   }
 
   SetComputedLogicalOffsets(offsets.ConvertTo(wm, cbwm));
 
   bool iSizeIsAuto = eStyleUnit_Auto == mStylePosition->ISize(cbwm).GetUnit();
   bool bSizeIsAuto = eStyleUnit_Auto == mStylePosition->BSize(cbwm).GetUnit();
--- a/layout/generic/nsHTMLReflowState.h
+++ b/layout/generic/nsHTMLReflowState.h
@@ -904,40 +904,49 @@ protected:
   void InitConstraints(nsPresContext*              aPresContext,
                        const mozilla::LogicalSize& aContainingBlockSize,
                        const nsMargin*             aBorder,
                        const nsMargin*             aPadding,
                        nsIAtom*                    aFrameType);
 
   // Returns the nearest containing block or block frame (whether or not
   // it is a containing block) for the specified frame.  Also returns
-  // the inline-start edge and inline size of the containing block's
+  // the inline-start edge and logical size of the containing block's
   // content area.
   // These are returned in the coordinate space of the containing block.
   nsIFrame* GetHypotheticalBoxContainer(nsIFrame* aFrame,
                                         nscoord& aCBIStartEdge,
-                                        nscoord& aCBISize);
+                                        mozilla::LogicalSize& aCBSize);
 
+  // Calculate a "hypothetical box" position where the placeholder frame
+  // (for a position:fixed/absolute element) would have been placed if it were
+  // positioned statically. The hypothetical box will have a writing mode with
+  // the same block direction as the absolute containing block (cbrs->frame),
+  // though it may differ in inline-bidi direction.
   void CalculateHypotheticalBox(nsPresContext*    aPresContext,
                                 nsIFrame*         aPlaceholderFrame,
                                 const nsHTMLReflowState* cbrs,
                                 nsHypotheticalBox& aHypotheticalBox,
                                 nsIAtom*          aFrameType);
 
   void InitAbsoluteConstraints(nsPresContext* aPresContext,
                                const nsHTMLReflowState* cbrs,
                                const mozilla::LogicalSize& aContainingBlockSize,
                                nsIAtom* aFrameType);
 
   // Calculates the computed values for the 'min-Width', 'max-Width',
   // 'min-Height', and 'max-Height' properties, and stores them in the assorted
   // data members
   void ComputeMinMaxValues(const mozilla::LogicalSize& aContainingBlockSize);
 
-  void CalculateInlineBorderPaddingMargin(nscoord aContainingBlockISize,
-                                          nscoord* aInsideBoxSizing,
-                                          nscoord* aOutsideBoxSizing);
+  // aInsideBoxSizing returns the part of the padding, border, and margin
+  // in the aAxis dimension that goes inside the edge given by box-sizing;
+  // aOutsideBoxSizing returns the rest.
+  void CalculateBorderPaddingMargin(mozilla::LogicalAxis aAxis,
+                                    nscoord aContainingBlockSize,
+                                    nscoord* aInsideBoxSizing,
+                                    nscoord* aOutsideBoxSizing);
 
   void CalculateBlockSideMargins(nsIAtom* aFrameType);
 };
 
 #endif /* nsHTMLReflowState_h___ */
 
--- a/layout/reftests/writing-mode/abspos/reftest.list
+++ b/layout/reftests/writing-mode/abspos/reftest.list
@@ -95,32 +95,32 @@ fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-084.xht s71-abs-pos-non-replaced-vrl-084-ref.xht
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-086.xht s71-abs-pos-non-replaced-vrl-086-ref.xht
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-088.xht s71-abs-pos-non-replaced-vrl-088-ref.xht
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-090.xht s71-abs-pos-non-replaced-vrl-090-ref.xht
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-092.xht s71-abs-pos-non-replaced-vrl-092-ref.xht
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-094.xht s71-abs-pos-non-replaced-vrl-094-ref.xht
 fuzzy-if(cocoaWidget,15,5) fuzzy-if(d2d,102,164) == s71-abs-pos-non-replaced-vrl-096.xht s71-abs-pos-non-replaced-vrl-096-ref.xht
 
-asserts(2) fails == 1183431-orthogonal-modes-1a.html 1183431-orthogonal-modes-1-ref.html
+== 1183431-orthogonal-modes-1a.html 1183431-orthogonal-modes-1-ref.html
 == 1183431-orthogonal-modes-1b.html 1183431-orthogonal-modes-1-ref.html
 == 1183431-orthogonal-modes-1c.html 1183431-orthogonal-modes-1-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-2a.html 1183431-orthogonal-modes-2-ref.html
+== 1183431-orthogonal-modes-2a.html 1183431-orthogonal-modes-2-ref.html
 == 1183431-orthogonal-modes-2b.html 1183431-orthogonal-modes-2-ref.html
 == 1183431-orthogonal-modes-2c.html 1183431-orthogonal-modes-2-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-3a.html 1183431-orthogonal-modes-3-ref.html
+== 1183431-orthogonal-modes-3a.html 1183431-orthogonal-modes-3-ref.html
 == 1183431-orthogonal-modes-3b.html 1183431-orthogonal-modes-3-ref.html
 == 1183431-orthogonal-modes-3c.html 1183431-orthogonal-modes-3-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-4a.html 1183431-orthogonal-modes-4-ref.html
+== 1183431-orthogonal-modes-4a.html 1183431-orthogonal-modes-4-ref.html
 == 1183431-orthogonal-modes-4b.html 1183431-orthogonal-modes-4-ref.html
 == 1183431-orthogonal-modes-4c.html 1183431-orthogonal-modes-4-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-5a.html 1183431-orthogonal-modes-5-ref.html
+== 1183431-orthogonal-modes-5a.html 1183431-orthogonal-modes-5-ref.html
 == 1183431-orthogonal-modes-5b.html 1183431-orthogonal-modes-5-ref.html
 == 1183431-orthogonal-modes-5c.html 1183431-orthogonal-modes-5-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-6a.html 1183431-orthogonal-modes-6-ref.html
+fails == 1183431-orthogonal-modes-6a.html 1183431-orthogonal-modes-6-ref.html # bug 1191801
 == 1183431-orthogonal-modes-6b.html 1183431-orthogonal-modes-6-ref.html
-fails == 1183431-orthogonal-modes-6c.html 1183431-orthogonal-modes-6-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-7a.html 1183431-orthogonal-modes-7-ref.html
+== 1183431-orthogonal-modes-6c.html 1183431-orthogonal-modes-6-ref.html
+== 1183431-orthogonal-modes-7a.html 1183431-orthogonal-modes-7-ref.html
 == 1183431-orthogonal-modes-7b.html 1183431-orthogonal-modes-7-ref.html
 == 1183431-orthogonal-modes-7c.html 1183431-orthogonal-modes-7-ref.html
-asserts(2) fails == 1183431-orthogonal-modes-8a.html 1183431-orthogonal-modes-8-ref.html
+fails == 1183431-orthogonal-modes-8a.html 1183431-orthogonal-modes-8-ref.html # bug 1191801
 == 1183431-orthogonal-modes-8b.html 1183431-orthogonal-modes-8-ref.html
 == 1183431-orthogonal-modes-8c.html 1183431-orthogonal-modes-8-ref.html