Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2215 insertions, 0 deletions

diff --git a/layout/generic/WritingModes.h b/layout/generic/WritingModes.h
new file mode 100644
index 0000000000..8f454891ec
--- /dev/null
+++ b/layout/generic/WritingModes.h
@@ -0,0 +1,2215 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef WritingModes_h_
+#define WritingModes_h_
+
+#include <ostream>
+
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/EnumeratedRange.h"
+
+#include "nsRect.h"
+#include "nsBidiUtils.h"
+
+// It is the caller's responsibility to operate on logical-coordinate objects
+// with matched writing modes. Failure to do so will be a runtime bug; the
+// compiler can't catch it, but in debug mode, we'll throw an assertion.
+// NOTE that in non-debug builds, a writing mode mismatch error will NOT be
+// detected, yet the results will be nonsense (and may lead to further layout
+// failures). Therefore, it is important to test (and fuzz-test) writing-mode
+// support using debug builds.
+
+// Methods in logical-coordinate classes that take another logical-coordinate
+// object as a parameter should call CHECK_WRITING_MODE on it to verify that
+// the writing modes match.
+// (In some cases, there are internal (private) methods that don't do this;
+// such methods should only be used by other methods that have already checked
+// the writing modes.)
+// The check ignores the StyleWritingMode::VERTICAL_SIDEWAYS and
+// StyleWritingMode::TEXT_SIDEWAYS bit of writing mode, because
+// this does not affect the interpretation of logical coordinates.
+
+#define CHECK_WRITING_MODE(param)                                           \
+  NS_ASSERTION(param.IgnoreSideways() == GetWritingMode().IgnoreSideways(), \
+               "writing-mode mismatch")
+
+namespace mozilla {
+
+namespace widget {
+struct IMENotification;
+}  // namespace widget
+
+// Logical axis, edge, side and corner constants for use in various places.
+enum LogicalAxis : uint8_t {
+  eLogicalAxisBlock = 0x0,
+  eLogicalAxisInline = 0x1
+};
+enum LogicalEdge { eLogicalEdgeStart = 0x0, eLogicalEdgeEnd = 0x1 };
+enum LogicalSide : uint8_t {
+  eLogicalSideBStart = (eLogicalAxisBlock << 1) | eLogicalEdgeStart,   // 0x0
+  eLogicalSideBEnd = (eLogicalAxisBlock << 1) | eLogicalEdgeEnd,       // 0x1
+  eLogicalSideIStart = (eLogicalAxisInline << 1) | eLogicalEdgeStart,  // 0x2
+  eLogicalSideIEnd = (eLogicalAxisInline << 1) | eLogicalEdgeEnd       // 0x3
+};
+constexpr auto AllLogicalSides() {
+  return mozilla::MakeInclusiveEnumeratedRange(eLogicalSideBStart,
+                                               eLogicalSideIEnd);
+}
+
+enum LogicalCorner {
+  eLogicalCornerBStartIStart = 0,
+  eLogicalCornerBStartIEnd = 1,
+  eLogicalCornerBEndIEnd = 2,
+  eLogicalCornerBEndIStart = 3
+};
+
+// Physical axis constants.
+enum PhysicalAxis { eAxisVertical = 0x0, eAxisHorizontal = 0x1 };
+
+inline LogicalAxis GetOrthogonalAxis(LogicalAxis aAxis) {
+  return aAxis == eLogicalAxisBlock ? eLogicalAxisInline : eLogicalAxisBlock;
+}
+
+inline bool IsInline(LogicalSide aSide) { return aSide & 0x2; }
+inline bool IsBlock(LogicalSide aSide) { return !IsInline(aSide); }
+inline bool IsEnd(LogicalSide aSide) { return aSide & 0x1; }
+inline bool IsStart(LogicalSide aSide) { return !IsEnd(aSide); }
+
+inline LogicalAxis GetAxis(LogicalSide aSide) {
+  return IsInline(aSide) ? eLogicalAxisInline : eLogicalAxisBlock;
+}
+
+inline LogicalEdge GetEdge(LogicalSide aSide) {
+  return IsEnd(aSide) ? eLogicalEdgeEnd : eLogicalEdgeStart;
+}
+
+inline LogicalEdge GetOppositeEdge(LogicalEdge aEdge) {
+  // This relies on the only two LogicalEdge enum values being 0 and 1.
+  return LogicalEdge(1 - aEdge);
+}
+
+inline LogicalSide MakeLogicalSide(LogicalAxis aAxis, LogicalEdge aEdge) {
+  return LogicalSide((aAxis << 1) | aEdge);
+}
+
+inline LogicalSide GetOppositeSide(LogicalSide aSide) {
+  return MakeLogicalSide(GetAxis(aSide), GetOppositeEdge(GetEdge(aSide)));
+}
+
+enum LogicalSideBits {
+  eLogicalSideBitsNone = 0,
+  eLogicalSideBitsBStart = 1 << eLogicalSideBStart,
+  eLogicalSideBitsBEnd = 1 << eLogicalSideBEnd,
+  eLogicalSideBitsIEnd = 1 << eLogicalSideIEnd,
+  eLogicalSideBitsIStart = 1 << eLogicalSideIStart,
+  eLogicalSideBitsBBoth = eLogicalSideBitsBStart | eLogicalSideBitsBEnd,
+  eLogicalSideBitsIBoth = eLogicalSideBitsIStart | eLogicalSideBitsIEnd,
+  eLogicalSideBitsAll = eLogicalSideBitsBBoth | eLogicalSideBitsIBoth
+};
+
+enum LineRelativeDir {
+  eLineRelativeDirOver = eLogicalSideBStart,
+  eLineRelativeDirUnder = eLogicalSideBEnd,
+  eLineRelativeDirLeft = eLogicalSideIStart,
+  eLineRelativeDirRight = eLogicalSideIEnd
+};
+
+/**
+ * mozilla::WritingMode is an immutable class representing a
+ * writing mode.
+ *
+ * It efficiently stores the writing mode and can rapidly compute
+ * interesting things about it for use in layout.
+ *
+ * Writing modes are computed from the CSS 'direction',
+ * 'writing-mode', and 'text-orientation' properties.
+ * See CSS3 Writing Modes for more information
+ *   http://www.w3.org/TR/css3-writing-modes/
+ */
+class WritingMode {
+ public:
+  /**
+   * Absolute inline flow direction
+   */
+  enum InlineDir {
+    eInlineLTR = 0x00,  // text flows horizontally left to right
+    eInlineRTL = 0x02,  // text flows horizontally right to left
+    eInlineTTB = 0x01,  // text flows vertically top to bottom
+    eInlineBTT = 0x03,  // text flows vertically bottom to top
+  };
+
+  /**
+   * Absolute block flow direction
+   */
+  enum BlockDir {
+    eBlockTB = 0x00,  // horizontal lines stack top to bottom
+    eBlockRL = 0x01,  // vertical lines stack right to left
+    eBlockLR = 0x05,  // vertical lines stack left to right
+  };
+
+  /**
+   * Line-relative (bidi-relative) inline flow direction
+   */
+  enum BidiDir {
+    eBidiLTR = 0x00,  // inline flow matches bidi LTR text
+    eBidiRTL = 0x10,  // inline flow matches bidi RTL text
+  };
+
+  /**
+   * Unknown writing mode (should never actually be stored or used anywhere).
+   */
+  enum { eUnknownWritingMode = 0xff };
+
+  /**
+   * Return the absolute inline flow direction as an InlineDir
+   */
+  InlineDir GetInlineDir() const {
+    return InlineDir(mWritingMode.bits & eInlineMask);
+  }
+
+  /**
+   * Return the absolute block flow direction as a BlockDir
+   */
+  BlockDir GetBlockDir() const {
+    return BlockDir(mWritingMode.bits & eBlockMask);
+  }
+
+  /**
+   * Return the line-relative inline flow direction as a BidiDir
+   */
+  BidiDir GetBidiDir() const {
+    return BidiDir((mWritingMode & StyleWritingMode::RTL).bits);
+  }
+
+  /**
+   * Return true if the inline flow direction is against physical direction
+   * (i.e. right-to-left or bottom-to-top).
+   * This occurs when writing-mode is sideways-lr OR direction is rtl (but not
+   * if both of those are true).
+   */
+  bool IsInlineReversed() const {
+    return !!(mWritingMode & StyleWritingMode::INLINE_REVERSED);
+  }
+
+  /**
+   * Return true if bidi direction is LTR. (Convenience method)
+   */
+  bool IsBidiLTR() const { return eBidiLTR == GetBidiDir(); }
+
+  /**
+   * Return true if bidi direction is RTL. (Convenience method)
+   */
+  bool IsBidiRTL() const { return eBidiRTL == GetBidiDir(); }
+
+  /**
+   * True if it is vertical and vertical-lr, or is horizontal and bidi LTR.
+   */
+  bool IsPhysicalLTR() const {
+    return IsVertical() ? IsVerticalLR() : IsBidiLTR();
+  }
+
+  /**
+   * True if it is vertical and vertical-rl, or is horizontal and bidi RTL.
+   */
+  bool IsPhysicalRTL() const {
+    return IsVertical() ? IsVerticalRL() : IsBidiRTL();
+  }
+
+  /**
+   * True if vertical-mode block direction is LR (convenience method).
+   */
+  bool IsVerticalLR() const { return eBlockLR == GetBlockDir(); }
+
+  /**
+   * True if vertical-mode block direction is RL (convenience method).
+   */
+  bool IsVerticalRL() const { return eBlockRL == GetBlockDir(); }
+
+  /**
+   * True if vertical writing mode, i.e. when
+   * writing-mode: vertical-lr | vertical-rl.
+   */
+  bool IsVertical() const {
+    return !!(mWritingMode & StyleWritingMode::VERTICAL);
+  }
+
+  /**
+   * True if line-over/line-under are inverted from block-start/block-end.
+   * This is true only when writing-mode is vertical-lr.
+   */
+  bool IsLineInverted() const {
+    return !!(mWritingMode & StyleWritingMode::LINE_INVERTED);
+  }
+
+  /**
+   * Block-axis flow-relative to line-relative factor.
+   * May be used as a multiplication factor for block-axis coordinates
+   * to convert between flow- and line-relative coordinate systems (e.g.
+   * positioning an over- or under-line decoration).
+   */
+  int FlowRelativeToLineRelativeFactor() const {
+    return IsLineInverted() ? -1 : 1;
+  }
+
+  /**
+   * True if vertical sideways writing mode, i.e. when
+   * writing-mode: sideways-lr | sideways-rl.
+   */
+  bool IsVerticalSideways() const {
+    return !!(mWritingMode & StyleWritingMode::VERTICAL_SIDEWAYS);
+  }
+
+  /**
+   * True if this is writing-mode: sideways-rl (convenience method).
+   */
+  bool IsSidewaysRL() const { return IsVerticalRL() && IsVerticalSideways(); }
+
+  /**
+   * True if this is writing-mode: sideways-lr (convenience method).
+   */
+  bool IsSidewaysLR() const { return IsVerticalLR() && IsVerticalSideways(); }
+
+  /**
+   * True if either text-orientation or writing-mode will force all text to be
+   * rendered sideways in vertical lines, in which case we should prefer an
+   * alphabetic baseline; otherwise, the default is centered.
+   *
+   * Note that some glyph runs may be rendered sideways even if this is false,
+   * due to text-orientation:mixed resolution, but in that case the dominant
+   * baseline remains centered.
+   */
+  bool IsSideways() const {
+    return !!(mWritingMode & (StyleWritingMode::VERTICAL_SIDEWAYS |
+                              StyleWritingMode::TEXT_SIDEWAYS));
+  }
+
+#ifdef DEBUG
+  // Used by CHECK_WRITING_MODE to compare modes without regard for the
+  // StyleWritingMode::VERTICAL_SIDEWAYS or StyleWritingMode::TEXT_SIDEWAYS
+  // flags.
+  WritingMode IgnoreSideways() const {
+    return WritingMode(
+        mWritingMode.bits &
+        ~(StyleWritingMode::VERTICAL_SIDEWAYS | StyleWritingMode::TEXT_SIDEWAYS)
+             .bits);
+  }
+#endif
+
+  /**
+   * Return true if boxes with this writing mode should use central baselines.
+   */
+  bool IsCentralBaseline() const { return IsVertical() && !IsSideways(); }
+
+  /**
+   * Return true if boxes with this writing mode should use alphabetical
+   * baselines.
+   */
+  bool IsAlphabeticalBaseline() const { return !IsCentralBaseline(); }
+
+  static mozilla::PhysicalAxis PhysicalAxisForLogicalAxis(
+      uint8_t aWritingModeValue, LogicalAxis aAxis) {
+    // This relies on bit 0 of a writing-value mode indicating vertical
+    // orientation and bit 0 of a LogicalAxis value indicating the inline axis,
+    // so that it can correctly form mozilla::PhysicalAxis values using bit
+    // manipulation.
+    static_assert(uint8_t(StyleWritingModeProperty::HorizontalTb) == 0 &&
+                      uint8_t(StyleWritingModeProperty::VerticalRl) == 1 &&
+                      uint8_t(StyleWritingModeProperty::VerticalLr) == 3 &&
+                      eLogicalAxisBlock == 0 && eLogicalAxisInline == 1 &&
+                      eAxisVertical == 0 && eAxisHorizontal == 1,
+                  "unexpected writing-mode, logical axis or physical axis "
+                  "constant values");
+    return mozilla::PhysicalAxis((aWritingModeValue ^ aAxis) & 0x1);
+  }
+
+  mozilla::PhysicalAxis PhysicalAxis(LogicalAxis aAxis) const {
+    // This will set wm to either StyleWritingModel::HorizontalTB or
+    // StyleWritingModeProperty::VerticalRL, and not the other two (real
+    // and hypothetical) values.  But this is fine; we only need to
+    // distinguish between vertical and horizontal in
+    // PhysicalAxisForLogicalAxis.
+    const auto wm = (mWritingMode & StyleWritingMode::VERTICAL).bits;
+    return PhysicalAxisForLogicalAxis(wm, aAxis);
+  }
+
+  static mozilla::Side PhysicalSideForBlockAxis(uint8_t aWritingModeValue,
+                                                LogicalEdge aEdge) {
+    // indexes are StyleWritingModeProperty values, which are the same as these
+    // two-bit values:
+    //   bit 0 = the StyleWritingMode::VERTICAL value
+    //   bit 1 = the StyleWritingMode::VERTICAL_LR value
+    static const mozilla::Side kLogicalBlockSides[][2] = {
+        {eSideTop, eSideBottom},  // horizontal-tb
+        {eSideRight, eSideLeft},  // vertical-rl
+        {eSideBottom, eSideTop},  // (horizontal-bt)
+        {eSideLeft, eSideRight},  // vertical-lr
+    };
+
+    // Ignore the SidewaysMask bit of the writing-mode value, as this has no
+    // effect on the side mappings.
+    aWritingModeValue &= ~kWritingModeSidewaysMask;
+
+    // What's left of the writing-mode should be in the range 0-3:
+    NS_ASSERTION(aWritingModeValue < 4, "invalid aWritingModeValue value");
+
+    return kLogicalBlockSides[aWritingModeValue][aEdge];
+  }
+
+  mozilla::Side PhysicalSideForInlineAxis(LogicalEdge aEdge) const {
+    // indexes are four-bit values:
+    //   bit 0 = the StyleWritingMode::VERTICAL value
+    //   bit 1 = the StyleWritingMode::INLINE_REVERSED value
+    //   bit 2 = the StyleWritingMode::VERTICAL_LR value
+    //   bit 3 = the StyleWritingMode::LINE_INVERTED value
+    // Not all of these combinations can actually be specified via CSS: there
+    // is no horizontal-bt writing-mode, and no text-orientation value that
+    // produces "inverted" text. (The former 'sideways-left' value, no longer
+    // in the spec, would have produced this in vertical-rl mode.)
+    static const mozilla::Side kLogicalInlineSides[][2] = {
+        {eSideLeft, eSideRight},  // horizontal-tb               ltr
+        {eSideTop, eSideBottom},  // vertical-rl                 ltr
+        {eSideRight, eSideLeft},  // horizontal-tb               rtl
+        {eSideBottom, eSideTop},  // vertical-rl                 rtl
+        {eSideRight, eSideLeft},  // (horizontal-bt)  (inverted) ltr
+        {eSideTop, eSideBottom},  // sideways-lr                 rtl
+        {eSideLeft, eSideRight},  // (horizontal-bt)  (inverted) rtl
+        {eSideBottom, eSideTop},  // sideways-lr                 ltr
+        {eSideLeft, eSideRight},  // horizontal-tb    (inverted) rtl
+        {eSideTop, eSideBottom},  // vertical-rl      (inverted) rtl
+        {eSideRight, eSideLeft},  // horizontal-tb    (inverted) ltr
+        {eSideBottom, eSideTop},  // vertical-rl      (inverted) ltr
+        {eSideLeft, eSideRight},  // (horizontal-bt)             ltr
+        {eSideTop, eSideBottom},  // vertical-lr                 ltr
+        {eSideRight, eSideLeft},  // (horizontal-bt)             rtl
+        {eSideBottom, eSideTop},  // vertical-lr                 rtl
+    };
+
+    // Inline axis sides depend on all three of writing-mode, text-orientation
+    // and direction, which are encoded in the StyleWritingMode::VERTICAL,
+    // StyleWritingMode::INLINE_REVERSED, StyleWritingMode::VERTICAL_LR and
+    // StyleWritingMode::LINE_INVERTED bits.  Use these four bits to index into
+    // kLogicalInlineSides.
+    MOZ_ASSERT(StyleWritingMode::VERTICAL.bits == 0x01 &&
+                   StyleWritingMode::INLINE_REVERSED.bits == 0x02 &&
+                   StyleWritingMode::VERTICAL_LR.bits == 0x04 &&
+                   StyleWritingMode::LINE_INVERTED.bits == 0x08,
+               "unexpected mask values");
+    int index = mWritingMode.bits & 0x0F;
+    return kLogicalInlineSides[index][aEdge];
+  }
+
+  /**
+   * Returns the physical side corresponding to the specified logical side,
+   * given the current writing mode.
+   */
+  mozilla::Side PhysicalSide(LogicalSide aSide) const {
+    if (IsBlock(aSide)) {
+      MOZ_ASSERT(StyleWritingMode::VERTICAL.bits == 0x01 &&
+                     StyleWritingMode::VERTICAL_LR.bits == 0x04,
+                 "unexpected mask values");
+      const uint8_t wm =
+          ((mWritingMode & StyleWritingMode::VERTICAL_LR).bits >> 1) |
+          (mWritingMode & StyleWritingMode::VERTICAL).bits;
+      return PhysicalSideForBlockAxis(wm, GetEdge(aSide));
+    }
+
+    return PhysicalSideForInlineAxis(GetEdge(aSide));
+  }
+
+  /**
+   * Returns the logical side corresponding to the specified physical side,
+   * given the current writing mode.
+   * (This is the inverse of the PhysicalSide() method above.)
+   */
+  LogicalSide LogicalSideForPhysicalSide(mozilla::Side aSide) const {
+    // clang-format off
+    // indexes are four-bit values:
+    //   bit 0 = the StyleWritingMode::VERTICAL value
+    //   bit 1 = the StyleWritingMode::INLINE_REVERSED value
+    //   bit 2 = the StyleWritingMode::VERTICAL_LR value
+    //   bit 3 = the StyleWritingMode::LINE_INVERTED value
+    static const LogicalSide kPhysicalToLogicalSides[][4] = {
+      // top                right
+      // bottom             left
+      { eLogicalSideBStart, eLogicalSideIEnd,
+        eLogicalSideBEnd,   eLogicalSideIStart },  // horizontal-tb         ltr
+      { eLogicalSideIStart, eLogicalSideBStart,
+        eLogicalSideIEnd,   eLogicalSideBEnd   },  // vertical-rl           ltr
+      { eLogicalSideBStart, eLogicalSideIStart,
+        eLogicalSideBEnd,   eLogicalSideIEnd   },  // horizontal-tb         rtl
+      { eLogicalSideIEnd,   eLogicalSideBStart,
+        eLogicalSideIStart, eLogicalSideBEnd   },  // vertical-rl           rtl
+      { eLogicalSideBEnd,   eLogicalSideIStart,
+        eLogicalSideBStart, eLogicalSideIEnd   },  // (horizontal-bt) (inv) ltr
+      { eLogicalSideIStart, eLogicalSideBEnd,
+        eLogicalSideIEnd,   eLogicalSideBStart },  // vertical-lr   sw-left rtl
+      { eLogicalSideBEnd,   eLogicalSideIEnd,
+        eLogicalSideBStart, eLogicalSideIStart },  // (horizontal-bt) (inv) rtl
+      { eLogicalSideIEnd,   eLogicalSideBEnd,
+        eLogicalSideIStart, eLogicalSideBStart },  // vertical-lr   sw-left ltr
+      { eLogicalSideBStart, eLogicalSideIEnd,
+        eLogicalSideBEnd,   eLogicalSideIStart },  // horizontal-tb   (inv) rtl
+      { eLogicalSideIStart, eLogicalSideBStart,
+        eLogicalSideIEnd,   eLogicalSideBEnd   },  // vertical-rl   sw-left rtl
+      { eLogicalSideBStart, eLogicalSideIStart,
+        eLogicalSideBEnd,   eLogicalSideIEnd   },  // horizontal-tb   (inv) ltr
+      { eLogicalSideIEnd,   eLogicalSideBStart,
+        eLogicalSideIStart, eLogicalSideBEnd   },  // vertical-rl   sw-left ltr
+      { eLogicalSideBEnd,   eLogicalSideIEnd,
+        eLogicalSideBStart, eLogicalSideIStart },  // (horizontal-bt)       ltr
+      { eLogicalSideIStart, eLogicalSideBEnd,
+        eLogicalSideIEnd,   eLogicalSideBStart },  // vertical-lr           ltr
+      { eLogicalSideBEnd,   eLogicalSideIStart,
+        eLogicalSideBStart, eLogicalSideIEnd   },  // (horizontal-bt)       rtl
+      { eLogicalSideIEnd,   eLogicalSideBEnd,
+        eLogicalSideIStart, eLogicalSideBStart },  // vertical-lr           rtl
+    };
+    // clang-format on
+
+    MOZ_ASSERT(StyleWritingMode::VERTICAL.bits == 0x01 &&
+                   StyleWritingMode::INLINE_REVERSED.bits == 0x02 &&
+                   StyleWritingMode::VERTICAL_LR.bits == 0x04 &&
+                   StyleWritingMode::LINE_INVERTED.bits == 0x08,
+               "unexpected mask values");
+    int index = mWritingMode.bits & 0x0F;
+    return kPhysicalToLogicalSides[index][aSide];
+  }
+
+  /**
+   * Returns the logical side corresponding to the specified
+   * line-relative direction, given the current writing mode.
+   */
+  LogicalSide LogicalSideForLineRelativeDir(LineRelativeDir aDir) const {
+    auto side = static_cast<LogicalSide>(aDir);
+    if (IsInline(side)) {
+      return IsBidiLTR() ? side : GetOppositeSide(side);
+    }
+    return !IsLineInverted() ? side : GetOppositeSide(side);
+  }
+
+  /**
+   * Default constructor gives us a horizontal, LTR writing mode.
+   * XXX We will probably eliminate this and require explicit initialization
+   *     in all cases once transition is complete.
+   */
+  WritingMode() : mWritingMode{0} {}
+
+  /**
+   * Construct writing mode based on a ComputedStyle.
+   */
+  explicit WritingMode(const ComputedStyle* aComputedStyle) {
+    NS_ASSERTION(aComputedStyle, "we need an ComputedStyle here");
+    mWritingMode = aComputedStyle->WritingMode();
+  }
+
+  /**
+   * This function performs fixup for elements with 'unicode-bidi: plaintext',
+   * where inline directionality is derived from the Unicode bidi categories
+   * of the element's content, and not the CSS 'direction' property.
+   *
+   * The WritingMode constructor will have already incorporated the 'direction'
+   * property into our flag bits, so such elements need to use this method
+   * (after resolving the bidi level of their content) to update the direction
+   * bits as needed.
+   *
+   * If it turns out that our bidi direction already matches what plaintext
+   * resolution determined, there's nothing to do here. If it didn't (i.e. if
+   * the rtl-ness doesn't match), then we correct the direction by flipping the
+   * same bits that get flipped in the constructor's CSS 'direction'-based
+   * chunk.
+   *
+   * XXX change uint8_t to UBiDiLevel after bug 924851
+   */
+  void SetDirectionFromBidiLevel(uint8_t level) {
+    if (IS_LEVEL_RTL(level) == IsBidiLTR()) {
+      mWritingMode ^= StyleWritingMode::RTL | StyleWritingMode::INLINE_REVERSED;
+    }
+  }
+
+  /**
+   * Compare two WritingModes for equality.
+   */
+  bool operator==(const WritingMode& aOther) const {
+    return mWritingMode == aOther.mWritingMode;
+  }
+
+  bool operator!=(const WritingMode& aOther) const {
+    return mWritingMode != aOther.mWritingMode;
+  }
+
+  /**
+   * Check whether two modes are orthogonal to each other.
+   */
+  bool IsOrthogonalTo(const WritingMode& aOther) const {
+    return IsVertical() != aOther.IsVertical();
+  }
+
+  /**
+   * Returns true if this WritingMode's aLogicalAxis has the same physical
+   * start side as the parallel axis of WritingMode |aOther|.
+   *
+   * @param aLogicalAxis The axis to compare from this WritingMode.
+   * @param aOther The other WritingMode (from which we'll choose the axis
+   *               that's parallel to this WritingMode's aLogicalAxis, for
+   *               comparison).
+   */
+  bool ParallelAxisStartsOnSameSide(LogicalAxis aLogicalAxis,
+                                    const WritingMode& aOther) const {
+    mozilla::Side myStartSide =
+        this->PhysicalSide(MakeLogicalSide(aLogicalAxis, eLogicalEdgeStart));
+
+    // Figure out which of aOther's axes is parallel to |this| WritingMode's
+    // aLogicalAxis, and get its physical start side as well.
+    LogicalAxis otherWMAxis = aOther.IsOrthogonalTo(*this)
+                                  ? GetOrthogonalAxis(aLogicalAxis)
+                                  : aLogicalAxis;
+    mozilla::Side otherWMStartSide =
+        aOther.PhysicalSide(MakeLogicalSide(otherWMAxis, eLogicalEdgeStart));
+
+    NS_ASSERTION(myStartSide % 2 == otherWMStartSide % 2,
+                 "Should end up with sides in the same physical axis");
+    return myStartSide == otherWMStartSide;
+  }
+
+  uint8_t GetBits() const { return mWritingMode.bits; }
+
+ private:
+  friend class LogicalPoint;
+  friend class LogicalSize;
+  friend struct LogicalSides;
+  friend class LogicalMargin;
+  friend class LogicalRect;
+
+  friend struct IPC::ParamTraits<WritingMode>;
+  // IMENotification cannot store this class directly since this has some
+  // constructors.  Therefore, it stores mWritingMode and recreate the
+  // instance from it.
+  friend struct widget::IMENotification;
+
+  /**
+   * Return a WritingMode representing an unknown value.
+   */
+  static inline WritingMode Unknown() {
+    return WritingMode(eUnknownWritingMode);
+  }
+
+  /**
+   * Constructing a WritingMode with an arbitrary value is a private operation
+   * currently only used by the Unknown() and IgnoreSideways() methods.
+   */
+  explicit WritingMode(uint8_t aValue) : mWritingMode{aValue} {}
+
+  StyleWritingMode mWritingMode;
+
+  enum Masks {
+    // Masks for output enums
+    eInlineMask = 0x03,  // VERTICAL | INLINE_REVERSED
+    eBlockMask = 0x05,   // VERTICAL | VERTICAL_LR
+  };
+};
+
+inline std::ostream& operator<<(std::ostream& aStream, const WritingMode& aWM) {
+  return aStream << (aWM.IsVertical()
+                         ? aWM.IsVerticalLR() ? aWM.IsBidiLTR()
+                                                    ? aWM.IsSideways()
+                                                          ? "sw-lr-ltr"
+                                                          : "v-lr-ltr"
+                                                : aWM.IsSideways() ? "sw-lr-rtl"
+                                                                   : "v-lr-rtl"
+                           : aWM.IsBidiLTR()
+                               ? aWM.IsSideways() ? "sw-rl-ltr" : "v-rl-ltr"
+                           : aWM.IsSideways() ? "sw-rl-rtl"
+                                              : "v-rl-rtl"
+                     : aWM.IsBidiLTR() ? "h-ltr"
+                                       : "h-rtl");
+}
+
+/**
+ * Logical-coordinate classes:
+ *
+ * There are three sets of coordinate space:
+ *   - physical (top, left, bottom, right)
+ *       relative to graphics coord system
+ *   - flow-relative (block-start, inline-start, block-end, inline-end)
+ *       relative to block/inline flow directions
+ *   - line-relative (line-over, line-left, line-under, line-right)
+ *       relative to glyph orientation / inline bidi directions
+ * See CSS3 Writing Modes for more information
+ *   http://www.w3.org/TR/css3-writing-modes/#abstract-box
+ *
+ * For shorthand, B represents the block-axis
+ *                I represents the inline-axis
+ *
+ * The flow-relative geometric classes store coords in flow-relative space.
+ * They use a private ns{Point,Size,Rect,Margin} member to store the actual
+ * coordinate values, but reinterpret them as logical instead of physical.
+ * This allows us to easily perform calculations in logical space (provided
+ * writing modes of the operands match), by simply mapping to nsPoint (etc)
+ * methods.
+ *
+ * Physical-coordinate accessors/setters are responsible to translate these
+ * internal logical values as necessary.
+ *
+ * In DEBUG builds, the logical types store their WritingMode and check
+ * that the same WritingMode is passed whenever callers ask them to do a
+ * writing-mode-dependent operation. Non-DEBUG builds do NOT check this,
+ * to avoid the overhead of storing WritingMode fields.
+ *
+ * Open question: do we need a different set optimized for line-relative
+ * math, for use in nsLineLayout and the like? Or is multiplying values
+ * by FlowRelativeToLineRelativeFactor() enough?
+ */
+
+/**
+ * Flow-relative point
+ */
+class LogicalPoint {
+ public:
+  explicit LogicalPoint(WritingMode aWritingMode)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mPoint(0, 0) {
+  }
+
+  // Construct from a writing mode and individual coordinates (which MUST be
+  // values in that writing mode, NOT physical coordinates!)
+  LogicalPoint(WritingMode aWritingMode, nscoord aI, nscoord aB)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mPoint(aI, aB) {
+  }
+
+  // Construct from a writing mode and a physical point, within a given
+  // containing rectangle's size (defining the conversion between LTR
+  // and RTL coordinates, and between TTB and BTT coordinates).
+  LogicalPoint(WritingMode aWritingMode, const nsPoint& aPoint,
+               const nsSize& aContainerSize)
+#ifdef DEBUG
+      : mWritingMode(aWritingMode)
+#endif
+  {
+    if (aWritingMode.IsVertical()) {
+      I() = aWritingMode.IsInlineReversed() ? aContainerSize.height - aPoint.y
+                                            : aPoint.y;
+      B() = aWritingMode.IsVerticalLR() ? aPoint.x
+                                        : aContainerSize.width - aPoint.x;
+    } else {
+      I() = aWritingMode.IsInlineReversed() ? aContainerSize.width - aPoint.x
+                                            : aPoint.x;
+      B() = aPoint.y;
+    }
+  }
+
+  /**
+   * Read-only (const) access to the logical coordinates.
+   */
+  nscoord I(WritingMode aWritingMode) const  // inline-axis
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mPoint.x;
+  }
+  nscoord B(WritingMode aWritingMode) const  // block-axis
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mPoint.y;
+  }
+  nscoord Pos(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? I(aWM) : B(aWM);
+  }
+  nscoord LineRelative(WritingMode aWritingMode,
+                       const nsSize& aContainerSize) const  // line-axis
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsBidiLTR()) {
+      return I();
+    }
+    return (aWritingMode.IsVertical() ? aContainerSize.height
+                                      : aContainerSize.width) -
+           I();
+  }
+
+  /**
+   * These non-const accessors return a reference (lvalue) that can be
+   * assigned to by callers.
+   */
+  nscoord& I(WritingMode aWritingMode)  // inline-axis
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mPoint.x;
+  }
+  nscoord& B(WritingMode aWritingMode)  // block-axis
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mPoint.y;
+  }
+  nscoord& Pos(LogicalAxis aAxis, WritingMode aWM) {
+    return aAxis == eLogicalAxisInline ? I(aWM) : B(aWM);
+  }
+
+  /**
+   * Return a physical point corresponding to our logical coordinates,
+   * converted according to our writing mode.
+   */
+  nsPoint GetPhysicalPoint(WritingMode aWritingMode,
+                           const nsSize& aContainerSize) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsVertical()) {
+      return nsPoint(
+          aWritingMode.IsVerticalLR() ? B() : aContainerSize.width - B(),
+          aWritingMode.IsInlineReversed() ? aContainerSize.height - I() : I());
+    } else {
+      return nsPoint(
+          aWritingMode.IsInlineReversed() ? aContainerSize.width - I() : I(),
+          B());
+    }
+  }
+
+  /**
+   * Return the equivalent point in a different writing mode.
+   */
+  LogicalPoint ConvertTo(WritingMode aToMode, WritingMode aFromMode,
+                         const nsSize& aContainerSize) const {
+    CHECK_WRITING_MODE(aFromMode);
+    return aToMode == aFromMode
+               ? *this
+               : LogicalPoint(aToMode,
+                              GetPhysicalPoint(aFromMode, aContainerSize),
+                              aContainerSize);
+  }
+
+  bool operator==(const LogicalPoint& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return mPoint == aOther.mPoint;
+  }
+
+  bool operator!=(const LogicalPoint& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return mPoint != aOther.mPoint;
+  }
+
+  LogicalPoint operator+(const LogicalPoint& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    // In non-debug builds, LogicalPoint does not store the WritingMode,
+    // so the first parameter here (which will always be eUnknownWritingMode)
+    // is ignored.
+    return LogicalPoint(GetWritingMode(), mPoint.x + aOther.mPoint.x,
+                        mPoint.y + aOther.mPoint.y);
+  }
+
+  LogicalPoint& operator+=(const LogicalPoint& aOther) {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    I() += aOther.I();
+    B() += aOther.B();
+    return *this;
+  }
+
+  LogicalPoint operator-(const LogicalPoint& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    // In non-debug builds, LogicalPoint does not store the WritingMode,
+    // so the first parameter here (which will always be eUnknownWritingMode)
+    // is ignored.
+    return LogicalPoint(GetWritingMode(), mPoint.x - aOther.mPoint.x,
+                        mPoint.y - aOther.mPoint.y);
+  }
+
+  LogicalPoint& operator-=(const LogicalPoint& aOther) {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    I() -= aOther.I();
+    B() -= aOther.B();
+    return *this;
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const LogicalPoint& aPoint) {
+    return aStream << aPoint.mPoint;
+  }
+
+ private:
+  friend class LogicalRect;
+
+  /**
+   * NOTE that in non-DEBUG builds, GetWritingMode() always returns
+   * eUnknownWritingMode, as the current mode is not stored in the logical-
+   * geometry classes. Therefore, this method is private; it is used ONLY
+   * by the DEBUG-mode checking macros in this class and its friends;
+   * other code is not allowed to ask a logical point for its writing mode,
+   * as this info will simply not be available in non-DEBUG builds.
+   *
+   * Also, in non-DEBUG builds, CHECK_WRITING_MODE does nothing, and the
+   * WritingMode parameter to logical methods will generally be optimized
+   * away altogether.
+   */
+#ifdef DEBUG
+  WritingMode GetWritingMode() const { return mWritingMode; }
+#else
+  WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
+#endif
+
+  // We don't allow construction of a LogicalPoint with no writing mode.
+  LogicalPoint() = delete;
+
+  // Accessors that don't take or check a WritingMode value.
+  // These are for internal use only; they are called by methods that have
+  // themselves already checked the WritingMode passed by the caller.
+  nscoord I() const  // inline-axis
+  {
+    return mPoint.x;
+  }
+  nscoord B() const  // block-axis
+  {
+    return mPoint.y;
+  }
+
+  nscoord& I()  // inline-axis
+  {
+    return mPoint.x;
+  }
+  nscoord& B()  // block-axis
+  {
+    return mPoint.y;
+  }
+
+#ifdef DEBUG
+  WritingMode mWritingMode;
+#endif
+
+  // We use an nsPoint to hold the coordinates, but reinterpret its .x and .y
+  // fields as the inline and block directions. Hence, this is not exposed
+  // directly, but only through accessors that will map them according to the
+  // writing mode.
+  nsPoint mPoint;
+};
+
+/**
+ * Flow-relative size
+ */
+class LogicalSize {
+ public:
+  explicit LogicalSize(WritingMode aWritingMode)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mSize(0, 0) {
+  }
+
+  LogicalSize(WritingMode aWritingMode, nscoord aISize, nscoord aBSize)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mSize(aISize, aBSize) {
+  }
+
+  LogicalSize(WritingMode aWritingMode, const nsSize& aPhysicalSize)
+#ifdef DEBUG
+      : mWritingMode(aWritingMode)
+#endif
+  {
+    if (aWritingMode.IsVertical()) {
+      ISize() = aPhysicalSize.height;
+      BSize() = aPhysicalSize.width;
+    } else {
+      ISize() = aPhysicalSize.width;
+      BSize() = aPhysicalSize.height;
+    }
+  }
+
+  void SizeTo(WritingMode aWritingMode, nscoord aISize, nscoord aBSize) {
+    CHECK_WRITING_MODE(aWritingMode);
+    mSize.SizeTo(aISize, aBSize);
+  }
+
+  /**
+   * Dimensions in logical and physical terms
+   */
+  nscoord ISize(WritingMode aWritingMode) const  // inline-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mSize.width;
+  }
+  nscoord BSize(WritingMode aWritingMode) const  // block-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mSize.height;
+  }
+  nscoord Size(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? ISize(aWM) : BSize(aWM);
+  }
+
+  nscoord Width(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? BSize() : ISize();
+  }
+  nscoord Height(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? ISize() : BSize();
+  }
+
+  /**
+   * Writable references to the logical dimensions
+   */
+  nscoord& ISize(WritingMode aWritingMode)  // inline-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mSize.width;
+  }
+  nscoord& BSize(WritingMode aWritingMode)  // block-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mSize.height;
+  }
+  nscoord& Size(LogicalAxis aAxis, WritingMode aWM) {
+    return aAxis == eLogicalAxisInline ? ISize(aWM) : BSize(aWM);
+  }
+
+  /**
+   * Return an nsSize containing our physical dimensions
+   */
+  nsSize GetPhysicalSize(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? nsSize(BSize(), ISize())
+                                     : nsSize(ISize(), BSize());
+  }
+
+  /**
+   * Return a LogicalSize representing this size in a different writing mode
+   */
+  LogicalSize ConvertTo(WritingMode aToMode, WritingMode aFromMode) const {
+#ifdef DEBUG
+    // In DEBUG builds make sure to return a LogicalSize with the
+    // expected writing mode
+    CHECK_WRITING_MODE(aFromMode);
+    return aToMode == aFromMode
+               ? *this
+               : LogicalSize(aToMode, GetPhysicalSize(aFromMode));
+#else
+    // optimization for non-DEBUG builds where LogicalSize doesn't store
+    // the writing mode
+    return (aToMode == aFromMode || !aToMode.IsOrthogonalTo(aFromMode))
+               ? *this
+               : LogicalSize(aToMode, BSize(), ISize());
+#endif
+  }
+
+  /**
+   * Test if a size is (0, 0).
+   */
+  bool IsAllZero() const { return ISize() == 0 && BSize() == 0; }
+
+  /**
+   * Various binary operators on LogicalSize. These are valid ONLY for operands
+   * that share the same writing mode.
+   */
+  bool operator==(const LogicalSize& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return mSize == aOther.mSize;
+  }
+
+  bool operator!=(const LogicalSize& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return mSize != aOther.mSize;
+  }
+
+  LogicalSize operator+(const LogicalSize& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return LogicalSize(GetWritingMode(), ISize() + aOther.ISize(),
+                       BSize() + aOther.BSize());
+  }
+  LogicalSize& operator+=(const LogicalSize& aOther) {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    ISize() += aOther.ISize();
+    BSize() += aOther.BSize();
+    return *this;
+  }
+
+  LogicalSize operator-(const LogicalSize& aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return LogicalSize(GetWritingMode(), ISize() - aOther.ISize(),
+                       BSize() - aOther.BSize());
+  }
+  LogicalSize& operator-=(const LogicalSize& aOther) {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    ISize() -= aOther.ISize();
+    BSize() -= aOther.BSize();
+    return *this;
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const LogicalSize& aSize) {
+    return aStream << aSize.mSize;
+  }
+
+ private:
+  friend class LogicalRect;
+
+  LogicalSize() = delete;
+
+#ifdef DEBUG
+  WritingMode GetWritingMode() const { return mWritingMode; }
+#else
+  WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
+#endif
+
+  nscoord ISize() const  // inline-size
+  {
+    return mSize.width;
+  }
+  nscoord BSize() const  // block-size
+  {
+    return mSize.height;
+  }
+
+  nscoord& ISize()  // inline-size
+  {
+    return mSize.width;
+  }
+  nscoord& BSize()  // block-size
+  {
+    return mSize.height;
+  }
+
+#ifdef DEBUG
+  WritingMode mWritingMode;
+#endif
+  nsSize mSize;
+};
+
+/**
+ * LogicalSides represents a set of logical sides.
+ */
+struct LogicalSides final {
+  explicit LogicalSides(WritingMode aWritingMode)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mBits(0) {
+  }
+  LogicalSides(WritingMode aWritingMode, LogicalSideBits aSideBits)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mBits(aSideBits) {
+    MOZ_ASSERT((aSideBits & ~eLogicalSideBitsAll) == 0, "illegal side bits");
+  }
+  bool IsEmpty() const { return mBits == 0; }
+  bool BStart() const { return mBits & eLogicalSideBitsBStart; }
+  bool BEnd() const { return mBits & eLogicalSideBitsBEnd; }
+  bool IStart() const { return mBits & eLogicalSideBitsIStart; }
+  bool IEnd() const { return mBits & eLogicalSideBitsIEnd; }
+  bool Contains(LogicalSideBits aSideBits) const {
+    MOZ_ASSERT((aSideBits & ~eLogicalSideBitsAll) == 0, "illegal side bits");
+    return (mBits & aSideBits) == aSideBits;
+  }
+  LogicalSides operator|(LogicalSides aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return *this | LogicalSideBits(aOther.mBits);
+  }
+  LogicalSides operator|(LogicalSideBits aSideBits) const {
+    return LogicalSides(GetWritingMode(), LogicalSideBits(mBits | aSideBits));
+  }
+  LogicalSides& operator|=(LogicalSides aOther) {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return *this |= LogicalSideBits(aOther.mBits);
+  }
+  LogicalSides& operator|=(LogicalSideBits aSideBits) {
+    mBits |= aSideBits;
+    return *this;
+  }
+  bool operator==(LogicalSides aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return mBits == aOther.mBits;
+  }
+  bool operator!=(LogicalSides aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    return !(*this == aOther);
+  }
+
+#ifdef DEBUG
+  WritingMode GetWritingMode() const { return mWritingMode; }
+#else
+  WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
+#endif
+
+ private:
+#ifdef DEBUG
+  WritingMode mWritingMode;
+#endif
+  uint8_t mBits;
+};
+
+/**
+ * Flow-relative margin
+ */
+class LogicalMargin {
+ public:
+  explicit LogicalMargin(WritingMode aWritingMode)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mMargin(0, 0, 0, 0) {
+  }
+
+  LogicalMargin(WritingMode aWritingMode, nscoord aBStart, nscoord aIEnd,
+                nscoord aBEnd, nscoord aIStart)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mMargin(aBStart, aIEnd, aBEnd, aIStart) {
+  }
+
+  LogicalMargin(WritingMode aWritingMode, const nsMargin& aPhysicalMargin)
+#ifdef DEBUG
+      : mWritingMode(aWritingMode)
+#endif
+  {
+    if (aWritingMode.IsVertical()) {
+      if (aWritingMode.IsVerticalLR()) {
+        mMargin.top = aPhysicalMargin.left;
+        mMargin.bottom = aPhysicalMargin.right;
+      } else {
+        mMargin.top = aPhysicalMargin.right;
+        mMargin.bottom = aPhysicalMargin.left;
+      }
+      if (aWritingMode.IsInlineReversed()) {
+        mMargin.left = aPhysicalMargin.bottom;
+        mMargin.right = aPhysicalMargin.top;
+      } else {
+        mMargin.left = aPhysicalMargin.top;
+        mMargin.right = aPhysicalMargin.bottom;
+      }
+    } else {
+      mMargin.top = aPhysicalMargin.top;
+      mMargin.bottom = aPhysicalMargin.bottom;
+      if (aWritingMode.IsInlineReversed()) {
+        mMargin.left = aPhysicalMargin.right;
+        mMargin.right = aPhysicalMargin.left;
+      } else {
+        mMargin.left = aPhysicalMargin.left;
+        mMargin.right = aPhysicalMargin.right;
+      }
+    }
+  }
+
+  nscoord IStart(WritingMode aWritingMode) const  // inline-start margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.left;
+  }
+  nscoord IEnd(WritingMode aWritingMode) const  // inline-end margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.right;
+  }
+  nscoord BStart(WritingMode aWritingMode) const  // block-start margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.top;
+  }
+  nscoord BEnd(WritingMode aWritingMode) const  // block-end margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.bottom;
+  }
+  nscoord Start(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? IStart(aWM) : BStart(aWM);
+  }
+  nscoord End(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? IEnd(aWM) : BEnd(aWM);
+  }
+
+  nscoord& IStart(WritingMode aWritingMode)  // inline-start margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.left;
+  }
+  nscoord& IEnd(WritingMode aWritingMode)  // inline-end margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.right;
+  }
+  nscoord& BStart(WritingMode aWritingMode)  // block-start margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.top;
+  }
+  nscoord& BEnd(WritingMode aWritingMode)  // block-end margin
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.bottom;
+  }
+  nscoord& Start(LogicalAxis aAxis, WritingMode aWM) {
+    return aAxis == eLogicalAxisInline ? IStart(aWM) : BStart(aWM);
+  }
+  nscoord& End(LogicalAxis aAxis, WritingMode aWM) {
+    return aAxis == eLogicalAxisInline ? IEnd(aWM) : BEnd(aWM);
+  }
+
+  nscoord IStartEnd(WritingMode aWritingMode) const  // inline margins
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.LeftRight();
+  }
+  nscoord BStartEnd(WritingMode aWritingMode) const  // block margins
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mMargin.TopBottom();
+  }
+  nscoord StartEnd(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? IStartEnd(aWM) : BStartEnd(aWM);
+  }
+
+  nscoord Side(LogicalSide aSide, WritingMode aWM) const {
+    switch (aSide) {
+      case eLogicalSideBStart:
+        return BStart(aWM);
+      case eLogicalSideBEnd:
+        return BEnd(aWM);
+      case eLogicalSideIStart:
+        return IStart(aWM);
+      case eLogicalSideIEnd:
+        return IEnd(aWM);
+    }
+
+    MOZ_ASSERT_UNREACHABLE("We should handle all sides!");
+    return BStart(aWM);
+  }
+  nscoord& Side(LogicalSide aSide, WritingMode aWM) {
+    switch (aSide) {
+      case eLogicalSideBStart:
+        return BStart(aWM);
+      case eLogicalSideBEnd:
+        return BEnd(aWM);
+      case eLogicalSideIStart:
+        return IStart(aWM);
+      case eLogicalSideIEnd:
+        return IEnd(aWM);
+    }
+
+    MOZ_ASSERT_UNREACHABLE("We should handle all sides!");
+    return BStart(aWM);
+  }
+
+  /*
+   * Return margin values for line-relative sides, as defined in
+   * http://www.w3.org/TR/css-writing-modes-3/#line-directions:
+   *
+   * line-left
+   *     Nominally the side from which LTR text would start.
+   * line-right
+   *     Nominally the side from which RTL text would start. (Opposite of
+   *     line-left.)
+   */
+  nscoord LineLeft(WritingMode aWritingMode) const {
+    // We don't need to CHECK_WRITING_MODE here because the IStart or IEnd
+    // accessor that we call will do it.
+    return aWritingMode.IsBidiLTR() ? IStart(aWritingMode) : IEnd(aWritingMode);
+  }
+  nscoord LineRight(WritingMode aWritingMode) const {
+    return aWritingMode.IsBidiLTR() ? IEnd(aWritingMode) : IStart(aWritingMode);
+  }
+
+  /**
+   * Return a LogicalSize representing the total size of the inline-
+   * and block-dimension margins.
+   */
+  LogicalSize Size(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return LogicalSize(aWritingMode, IStartEnd(), BStartEnd());
+  }
+
+  /**
+   * Accessors for physical margins, using our writing mode to convert from
+   * logical values.
+   */
+  nscoord Top(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical()
+               ? (aWritingMode.IsInlineReversed() ? IEnd() : IStart())
+               : BStart();
+  }
+
+  nscoord Bottom(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical()
+               ? (aWritingMode.IsInlineReversed() ? IStart() : IEnd())
+               : BEnd();
+  }
+
+  nscoord Left(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical()
+               ? (aWritingMode.IsVerticalLR() ? BStart() : BEnd())
+               : (aWritingMode.IsInlineReversed() ? IEnd() : IStart());
+  }
+
+  nscoord Right(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical()
+               ? (aWritingMode.IsVerticalLR() ? BEnd() : BStart())
+               : (aWritingMode.IsInlineReversed() ? IStart() : IEnd());
+  }
+
+  nscoord LeftRight(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? BStartEnd() : IStartEnd();
+  }
+
+  nscoord TopBottom(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? IStartEnd() : BStartEnd();
+  }
+
+  void SizeTo(WritingMode aWritingMode, nscoord aBStart, nscoord aIEnd,
+              nscoord aBEnd, nscoord aIStart) {
+    CHECK_WRITING_MODE(aWritingMode);
+    mMargin.SizeTo(aBStart, aIEnd, aBEnd, aIStart);
+  }
+
+  /**
+   * Return an nsMargin containing our physical coordinates
+   */
+  nsMargin GetPhysicalMargin(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical()
+               ? (aWritingMode.IsVerticalLR()
+                      ? (aWritingMode.IsInlineReversed()
+                             ? nsMargin(IEnd(), BEnd(), IStart(), BStart())
+                             : nsMargin(IStart(), BEnd(), IEnd(), BStart()))
+                      : (aWritingMode.IsInlineReversed()
+                             ? nsMargin(IEnd(), BStart(), IStart(), BEnd())
+                             : nsMargin(IStart(), BStart(), IEnd(), BEnd())))
+               : (aWritingMode.IsInlineReversed()
+                      ? nsMargin(BStart(), IStart(), BEnd(), IEnd())
+                      : nsMargin(BStart(), IEnd(), BEnd(), IStart()));
+  }
+
+  /**
+   * Return a LogicalMargin representing this margin in a different
+   * writing mode
+   */
+  LogicalMargin ConvertTo(WritingMode aToMode, WritingMode aFromMode) const {
+    CHECK_WRITING_MODE(aFromMode);
+    return aToMode == aFromMode
+               ? *this
+               : LogicalMargin(aToMode, GetPhysicalMargin(aFromMode));
+  }
+
+  LogicalMargin& ApplySkipSides(LogicalSides aSkipSides) {
+    CHECK_WRITING_MODE(aSkipSides.GetWritingMode());
+    if (aSkipSides.BStart()) {
+      BStart() = 0;
+    }
+    if (aSkipSides.BEnd()) {
+      BEnd() = 0;
+    }
+    if (aSkipSides.IStart()) {
+      IStart() = 0;
+    }
+    if (aSkipSides.IEnd()) {
+      IEnd() = 0;
+    }
+    return *this;
+  }
+
+  bool IsAllZero() const {
+    return (mMargin.left == 0 && mMargin.top == 0 && mMargin.right == 0 &&
+            mMargin.bottom == 0);
+  }
+
+  LogicalMargin operator+(const LogicalMargin& aMargin) const {
+    CHECK_WRITING_MODE(aMargin.GetWritingMode());
+    return LogicalMargin(GetWritingMode(), BStart() + aMargin.BStart(),
+                         IEnd() + aMargin.IEnd(), BEnd() + aMargin.BEnd(),
+                         IStart() + aMargin.IStart());
+  }
+
+  LogicalMargin operator+=(const LogicalMargin& aMargin) {
+    CHECK_WRITING_MODE(aMargin.GetWritingMode());
+    mMargin += aMargin.mMargin;
+    return *this;
+  }
+
+  LogicalMargin operator-(const LogicalMargin& aMargin) const {
+    CHECK_WRITING_MODE(aMargin.GetWritingMode());
+    return LogicalMargin(GetWritingMode(), BStart() - aMargin.BStart(),
+                         IEnd() - aMargin.IEnd(), BEnd() - aMargin.BEnd(),
+                         IStart() - aMargin.IStart());
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const LogicalMargin& aMargin) {
+    return aStream << aMargin.mMargin;
+  }
+
+ private:
+  friend class LogicalRect;
+
+  LogicalMargin() = delete;
+
+#ifdef DEBUG
+  WritingMode GetWritingMode() const { return mWritingMode; }
+#else
+  WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
+#endif
+
+  nscoord IStart() const  // inline-start margin
+  {
+    return mMargin.left;
+  }
+  nscoord IEnd() const  // inline-end margin
+  {
+    return mMargin.right;
+  }
+  nscoord BStart() const  // block-start margin
+  {
+    return mMargin.top;
+  }
+  nscoord BEnd() const  // block-end margin
+  {
+    return mMargin.bottom;
+  }
+
+  nscoord& IStart()  // inline-start margin
+  {
+    return mMargin.left;
+  }
+  nscoord& IEnd()  // inline-end margin
+  {
+    return mMargin.right;
+  }
+  nscoord& BStart()  // block-start margin
+  {
+    return mMargin.top;
+  }
+  nscoord& BEnd()  // block-end margin
+  {
+    return mMargin.bottom;
+  }
+
+  nscoord IStartEnd() const  // inline margins
+  {
+    return mMargin.LeftRight();
+  }
+  nscoord BStartEnd() const  // block margins
+  {
+    return mMargin.TopBottom();
+  }
+
+#ifdef DEBUG
+  WritingMode mWritingMode;
+#endif
+  nsMargin mMargin;
+};
+
+/**
+ * Flow-relative rectangle
+ */
+class LogicalRect {
+ public:
+  explicit LogicalRect(WritingMode aWritingMode)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mIStart(0),
+        mBStart(0),
+        mISize(0),
+        mBSize(0) {
+  }
+
+  LogicalRect(WritingMode aWritingMode, nscoord aIStart, nscoord aBStart,
+              nscoord aISize, nscoord aBSize)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mIStart(aIStart),
+        mBStart(aBStart),
+        mISize(aISize),
+        mBSize(aBSize) {
+  }
+
+  LogicalRect(WritingMode aWritingMode, const LogicalPoint& aOrigin,
+              const LogicalSize& aSize)
+      :
+#ifdef DEBUG
+        mWritingMode(aWritingMode),
+#endif
+        mIStart(aOrigin.mPoint.x),
+        mBStart(aOrigin.mPoint.y),
+        mISize(aSize.mSize.width),
+        mBSize(aSize.mSize.height) {
+    CHECK_WRITING_MODE(aOrigin.GetWritingMode());
+    CHECK_WRITING_MODE(aSize.GetWritingMode());
+  }
+
+  LogicalRect(WritingMode aWritingMode, const nsRect& aRect,
+              const nsSize& aContainerSize)
+#ifdef DEBUG
+      : mWritingMode(aWritingMode)
+#endif
+  {
+    if (aWritingMode.IsVertical()) {
+      mBStart = aWritingMode.IsVerticalLR()
+                    ? aRect.X()
+                    : aContainerSize.width - aRect.XMost();
+      mIStart = aWritingMode.IsInlineReversed()
+                    ? aContainerSize.height - aRect.YMost()
+                    : aRect.Y();
+      mBSize = aRect.Width();
+      mISize = aRect.Height();
+    } else {
+      mIStart = aWritingMode.IsInlineReversed()
+                    ? aContainerSize.width - aRect.XMost()
+                    : aRect.X();
+      mBStart = aRect.Y();
+      mISize = aRect.Width();
+      mBSize = aRect.Height();
+    }
+  }
+
+  /**
+   * Inline- and block-dimension geometry.
+   */
+  nscoord IStart(WritingMode aWritingMode) const  // inline-start edge
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mIStart;
+  }
+  nscoord IEnd(WritingMode aWritingMode) const  // inline-end edge
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mIStart + mISize;
+  }
+  nscoord ISize(WritingMode aWritingMode) const  // inline-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mISize;
+  }
+
+  nscoord BStart(WritingMode aWritingMode) const  // block-start edge
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mBStart;
+  }
+  nscoord BEnd(WritingMode aWritingMode) const  // block-end edge
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mBStart + mBSize;
+  }
+  nscoord BSize(WritingMode aWritingMode) const  // block-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mBSize;
+  }
+
+  nscoord Start(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? IStart(aWM) : BStart(aWM);
+  }
+  nscoord End(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? IEnd(aWM) : BEnd(aWM);
+  }
+  nscoord Size(LogicalAxis aAxis, WritingMode aWM) const {
+    return aAxis == eLogicalAxisInline ? ISize(aWM) : BSize(aWM);
+  }
+
+  /**
+   * Writable (reference) accessors are only available for the basic logical
+   * fields (Start and Size), not derivatives like End.
+   */
+  nscoord& IStart(WritingMode aWritingMode)  // inline-start edge
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mIStart;
+  }
+  nscoord& ISize(WritingMode aWritingMode)  // inline-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mISize;
+  }
+  nscoord& BStart(WritingMode aWritingMode)  // block-start edge
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mBStart;
+  }
+  nscoord& BSize(WritingMode aWritingMode)  // block-size
+  {
+    CHECK_WRITING_MODE(aWritingMode);
+    return mBSize;
+  }
+  nscoord& Start(LogicalAxis aAxis, WritingMode aWM) {
+    return aAxis == eLogicalAxisInline ? IStart(aWM) : BStart(aWM);
+  }
+  nscoord& Size(LogicalAxis aAxis, WritingMode aWM) {
+    return aAxis == eLogicalAxisInline ? ISize(aWM) : BSize(aWM);
+  }
+
+  /**
+   * Accessors for line-relative coordinates
+   */
+  nscoord LineLeft(WritingMode aWritingMode,
+                   const nsSize& aContainerSize) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsBidiLTR()) {
+      return IStart();
+    }
+    nscoord containerISize = aWritingMode.IsVertical() ? aContainerSize.height
+                                                       : aContainerSize.width;
+    return containerISize - IEnd();
+  }
+  nscoord LineRight(WritingMode aWritingMode,
+                    const nsSize& aContainerSize) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsBidiLTR()) {
+      return IEnd();
+    }
+    nscoord containerISize = aWritingMode.IsVertical() ? aContainerSize.height
+                                                       : aContainerSize.width;
+    return containerISize - IStart();
+  }
+
+  /**
+   * Physical coordinates of the rect.
+   */
+  nscoord X(WritingMode aWritingMode, nscoord aContainerWidth) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsVertical()) {
+      return aWritingMode.IsVerticalLR() ? mBStart : aContainerWidth - BEnd();
+    }
+    return aWritingMode.IsInlineReversed() ? aContainerWidth - IEnd() : mIStart;
+  }
+
+  nscoord Y(WritingMode aWritingMode, nscoord aContainerHeight) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsVertical()) {
+      return aWritingMode.IsInlineReversed() ? aContainerHeight - IEnd()
+                                             : mIStart;
+    }
+    return mBStart;
+  }
+
+  nscoord Width(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? mBSize : mISize;
+  }
+
+  nscoord Height(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return aWritingMode.IsVertical() ? mISize : mBSize;
+  }
+
+  nscoord XMost(WritingMode aWritingMode, nscoord aContainerWidth) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsVertical()) {
+      return aWritingMode.IsVerticalLR() ? BEnd() : aContainerWidth - mBStart;
+    }
+    return aWritingMode.IsInlineReversed() ? aContainerWidth - mIStart : IEnd();
+  }
+
+  nscoord YMost(WritingMode aWritingMode, nscoord aContainerHeight) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsVertical()) {
+      return aWritingMode.IsInlineReversed() ? aContainerHeight - mIStart
+                                             : IEnd();
+    }
+    return BEnd();
+  }
+
+  bool IsEmpty() const { return mISize <= 0 || mBSize <= 0; }
+
+  bool IsAllZero() const {
+    return (mIStart == 0 && mBStart == 0 && mISize == 0 && mBSize == 0);
+  }
+
+  bool IsZeroSize() const { return (mISize == 0 && mBSize == 0); }
+
+  void SetEmpty() { mISize = mBSize = 0; }
+
+  bool IsEqualEdges(const LogicalRect aOther) const {
+    CHECK_WRITING_MODE(aOther.GetWritingMode());
+    bool result = mIStart == aOther.mIStart && mBStart == aOther.mBStart &&
+                  mISize == aOther.mISize && mBSize == aOther.mBSize;
+
+    // We want the same result as nsRect, so assert we get it.
+    MOZ_ASSERT(result ==
+               nsRect(mIStart, mBStart, mISize, mBSize)
+                   .IsEqualEdges(nsRect(aOther.mIStart, aOther.mBStart,
+                                        aOther.mISize, aOther.mBSize)));
+    return result;
+  }
+
+  LogicalPoint Origin(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return LogicalPoint(aWritingMode, IStart(), BStart());
+  }
+  void SetOrigin(WritingMode aWritingMode, const LogicalPoint& aPoint) {
+    IStart(aWritingMode) = aPoint.I(aWritingMode);
+    BStart(aWritingMode) = aPoint.B(aWritingMode);
+  }
+
+  LogicalSize Size(WritingMode aWritingMode) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    return LogicalSize(aWritingMode, ISize(), BSize());
+  }
+
+  LogicalRect operator+(const LogicalPoint& aPoint) const {
+    CHECK_WRITING_MODE(aPoint.GetWritingMode());
+    return LogicalRect(GetWritingMode(), IStart() + aPoint.I(),
+                       BStart() + aPoint.B(), ISize(), BSize());
+  }
+
+  LogicalRect& operator+=(const LogicalPoint& aPoint) {
+    CHECK_WRITING_MODE(aPoint.GetWritingMode());
+    mIStart += aPoint.mPoint.x;
+    mBStart += aPoint.mPoint.y;
+    return *this;
+  }
+
+  LogicalRect operator-(const LogicalPoint& aPoint) const {
+    CHECK_WRITING_MODE(aPoint.GetWritingMode());
+    return LogicalRect(GetWritingMode(), IStart() - aPoint.I(),
+                       BStart() - aPoint.B(), ISize(), BSize());
+  }
+
+  LogicalRect& operator-=(const LogicalPoint& aPoint) {
+    CHECK_WRITING_MODE(aPoint.GetWritingMode());
+    mIStart -= aPoint.mPoint.x;
+    mBStart -= aPoint.mPoint.y;
+    return *this;
+  }
+
+  void MoveBy(WritingMode aWritingMode, const LogicalPoint& aDelta) {
+    CHECK_WRITING_MODE(aWritingMode);
+    CHECK_WRITING_MODE(aDelta.GetWritingMode());
+    IStart() += aDelta.I();
+    BStart() += aDelta.B();
+  }
+
+  void Inflate(nscoord aD) {
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug(mIStart, mBStart, mISize, mBSize);
+    rectDebug.Inflate(aD);
+#endif
+    mIStart -= aD;
+    mBStart -= aD;
+    mISize += 2 * aD;
+    mBSize += 2 * aD;
+    MOZ_ASSERT(
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+  }
+  void Inflate(nscoord aDI, nscoord aDB) {
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug(mIStart, mBStart, mISize, mBSize);
+    rectDebug.Inflate(aDI, aDB);
+#endif
+    mIStart -= aDI;
+    mBStart -= aDB;
+    mISize += 2 * aDI;
+    mBSize += 2 * aDB;
+    MOZ_ASSERT(
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+  }
+  void Inflate(WritingMode aWritingMode, const LogicalMargin& aMargin) {
+    CHECK_WRITING_MODE(aWritingMode);
+    CHECK_WRITING_MODE(aMargin.GetWritingMode());
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug(mIStart, mBStart, mISize, mBSize);
+    rectDebug.Inflate(aMargin.mMargin);
+#endif
+    mIStart -= aMargin.mMargin.left;
+    mBStart -= aMargin.mMargin.top;
+    mISize += aMargin.mMargin.LeftRight();
+    mBSize += aMargin.mMargin.TopBottom();
+    MOZ_ASSERT(
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+  }
+
+  void Deflate(nscoord aD) {
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug(mIStart, mBStart, mISize, mBSize);
+    rectDebug.Deflate(aD);
+#endif
+    mIStart += aD;
+    mBStart += aD;
+    mISize = std::max(0, mISize - 2 * aD);
+    mBSize = std::max(0, mBSize - 2 * aD);
+    MOZ_ASSERT(
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+  }
+  void Deflate(nscoord aDI, nscoord aDB) {
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug(mIStart, mBStart, mISize, mBSize);
+    rectDebug.Deflate(aDI, aDB);
+#endif
+    mIStart += aDI;
+    mBStart += aDB;
+    mISize = std::max(0, mISize - 2 * aDI);
+    mBSize = std::max(0, mBSize - 2 * aDB);
+    MOZ_ASSERT(
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+  }
+  void Deflate(WritingMode aWritingMode, const LogicalMargin& aMargin) {
+    CHECK_WRITING_MODE(aWritingMode);
+    CHECK_WRITING_MODE(aMargin.GetWritingMode());
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug(mIStart, mBStart, mISize, mBSize);
+    rectDebug.Deflate(aMargin.mMargin);
+#endif
+    mIStart += aMargin.mMargin.left;
+    mBStart += aMargin.mMargin.top;
+    mISize = std::max(0, mISize - aMargin.mMargin.LeftRight());
+    mBSize = std::max(0, mBSize - aMargin.mMargin.TopBottom());
+    MOZ_ASSERT(
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+  }
+
+  /**
+   * Return an nsRect containing our physical coordinates within the given
+   * container size.
+   */
+  nsRect GetPhysicalRect(WritingMode aWritingMode,
+                         const nsSize& aContainerSize) const {
+    CHECK_WRITING_MODE(aWritingMode);
+    if (aWritingMode.IsVertical()) {
+      return nsRect(aWritingMode.IsVerticalLR() ? BStart()
+                                                : aContainerSize.width - BEnd(),
+                    aWritingMode.IsInlineReversed()
+                        ? aContainerSize.height - IEnd()
+                        : IStart(),
+                    BSize(), ISize());
+    } else {
+      return nsRect(aWritingMode.IsInlineReversed()
+                        ? aContainerSize.width - IEnd()
+                        : IStart(),
+                    BStart(), ISize(), BSize());
+    }
+  }
+
+  /**
+   * Return a LogicalRect representing this rect in a different writing mode
+   */
+  LogicalRect ConvertTo(WritingMode aToMode, WritingMode aFromMode,
+                        const nsSize& aContainerSize) const {
+    CHECK_WRITING_MODE(aFromMode);
+    return aToMode == aFromMode
+               ? *this
+               : LogicalRect(aToMode,
+                             GetPhysicalRect(aFromMode, aContainerSize),
+                             aContainerSize);
+  }
+
+  /**
+   * Set *this to be the rectangle containing the intersection of aRect1
+   * and aRect2, return whether the intersection is non-empty.
+   */
+  bool IntersectRect(const LogicalRect& aRect1, const LogicalRect& aRect2) {
+    CHECK_WRITING_MODE(aRect1.mWritingMode);
+    CHECK_WRITING_MODE(aRect2.mWritingMode);
+#ifdef DEBUG
+    // Compute using nsRect and assert the results match
+    nsRect rectDebug;
+    rectDebug.IntersectRect(
+        nsRect(aRect1.mIStart, aRect1.mBStart, aRect1.mISize, aRect1.mBSize),
+        nsRect(aRect2.mIStart, aRect2.mBStart, aRect2.mISize, aRect2.mBSize));
+#endif
+
+    nscoord iEnd = std::min(aRect1.IEnd(), aRect2.IEnd());
+    mIStart = std::max(aRect1.mIStart, aRect2.mIStart);
+    mISize = iEnd - mIStart;
+
+    nscoord bEnd = std::min(aRect1.BEnd(), aRect2.BEnd());
+    mBStart = std::max(aRect1.mBStart, aRect2.mBStart);
+    mBSize = bEnd - mBStart;
+
+    if (mISize < 0 || mBSize < 0) {
+      mISize = 0;
+      mBSize = 0;
+    }
+
+    MOZ_ASSERT(
+        (rectDebug.IsEmpty() && (mISize == 0 || mBSize == 0)) ||
+        rectDebug.IsEqualEdges(nsRect(mIStart, mBStart, mISize, mBSize)));
+    return mISize > 0 && mBSize > 0;
+  }
+
+  friend std::ostream& operator<<(std::ostream& aStream,
+                                  const LogicalRect& aRect) {
+    return aStream << '(' << aRect.IStart() << ',' << aRect.BStart() << ','
+                   << aRect.ISize() << ',' << aRect.BSize() << ')';
+  }
+
+ private:
+  LogicalRect() = delete;
+
+#ifdef DEBUG
+  WritingMode GetWritingMode() const { return mWritingMode; }
+#else
+  WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
+#endif
+
+  nscoord IStart() const  // inline-start edge
+  {
+    return mIStart;
+  }
+  nscoord IEnd() const  // inline-end edge
+  {
+    return mIStart + mISize;
+  }
+  nscoord ISize() const  // inline-size
+  {
+    return mISize;
+  }
+
+  nscoord BStart() const  // block-start edge
+  {
+    return mBStart;
+  }
+  nscoord BEnd() const  // block-end edge
+  {
+    return mBStart + mBSize;
+  }
+  nscoord BSize() const  // block-size
+  {
+    return mBSize;
+  }
+
+  nscoord& IStart()  // inline-start edge
+  {
+    return mIStart;
+  }
+  nscoord& ISize()  // inline-size
+  {
+    return mISize;
+  }
+  nscoord& BStart()  // block-start edge
+  {
+    return mBStart;
+  }
+  nscoord& BSize()  // block-size
+  {
+    return mBSize;
+  }
+
+#ifdef DEBUG
+  WritingMode mWritingMode;
+#endif
+  // Inline- and block-geometry dimension
+  nscoord mIStart;  // inline-start edge
+  nscoord mBStart;  // block-start edge
+  nscoord mISize;   // inline-size
+  nscoord mBSize;   // block-size
+};
+
+template <typename T>
+const T& StyleRect<T>::Get(WritingMode aWM, LogicalSide aSide) const {
+  return Get(aWM.PhysicalSide(aSide));
+}
+
+template <typename T>
+const T& StyleRect<T>::GetIStart(WritingMode aWM) const {
+  return Get(aWM, eLogicalSideIStart);
+}
+
+template <typename T>
+const T& StyleRect<T>::GetBStart(WritingMode aWM) const {
+  return Get(aWM, eLogicalSideBStart);
+}
+
+template <typename T>
+const T& StyleRect<T>::GetIEnd(WritingMode aWM) const {
+  return Get(aWM, eLogicalSideIEnd);
+}
+
+template <typename T>
+const T& StyleRect<T>::GetBEnd(WritingMode aWM) const {
+  return Get(aWM, eLogicalSideBEnd);
+}
+
+template <typename T>
+T& StyleRect<T>::Get(WritingMode aWM, LogicalSide aSide) {
+  return Get(aWM.PhysicalSide(aSide));
+}
+
+template <typename T>
+T& StyleRect<T>::GetIStart(WritingMode aWM) {
+  return Get(aWM, eLogicalSideIStart);
+}
+
+template <typename T>
+T& StyleRect<T>::GetBStart(WritingMode aWM) {
+  return Get(aWM, eLogicalSideBStart);
+}
+
+template <typename T>
+T& StyleRect<T>::GetIEnd(WritingMode aWM) {
+  return Get(aWM, eLogicalSideIEnd);
+}
+
+template <typename T>
+T& StyleRect<T>::GetBEnd(WritingMode aWM) {
+  return Get(aWM, eLogicalSideBEnd);
+}
+
+template <typename T>
+const T& StyleRect<T>::Start(mozilla::LogicalAxis aAxis,
+                             mozilla::WritingMode aWM) const {
+  return Get(aWM, aAxis == mozilla::eLogicalAxisInline
+                      ? mozilla::eLogicalSideIStart
+                      : mozilla::eLogicalSideBStart);
+}
+
+template <typename T>
+const T& StyleRect<T>::End(mozilla::LogicalAxis aAxis,
+                           mozilla::WritingMode aWM) const {
+  return Get(aWM, aAxis == mozilla::eLogicalAxisInline
+                      ? mozilla::eLogicalSideIEnd
+                      : mozilla::eLogicalSideBEnd);
+}
+
+inline AspectRatio AspectRatio::ConvertToWritingMode(
+    const WritingMode& aWM) const {
+  return aWM.IsVertical() ? Inverted() : *this;
+}
+
+}  // namespace mozilla
+
+// Definitions of inline methods for nsStylePosition, declared in
+// nsStyleStruct.h but not defined there because they need WritingMode.
+inline const mozilla::StyleSize& nsStylePosition::ISize(WritingMode aWM) const {
+  return aWM.IsVertical() ? mHeight : mWidth;
+}
+inline const mozilla::StyleSize& nsStylePosition::MinISize(
+    WritingMode aWM) const {
+  return aWM.IsVertical() ? mMinHeight : mMinWidth;
+}
+inline const mozilla::StyleMaxSize& nsStylePosition::MaxISize(
+    WritingMode aWM) const {
+  return aWM.IsVertical() ? mMaxHeight : mMaxWidth;
+}
+inline const mozilla::StyleSize& nsStylePosition::BSize(WritingMode aWM) const {
+  return aWM.IsVertical() ? mWidth : mHeight;
+}
+inline const mozilla::StyleSize& nsStylePosition::MinBSize(
+    WritingMode aWM) const {
+  return aWM.IsVertical() ? mMinWidth : mMinHeight;
+}
+inline const mozilla::StyleMaxSize& nsStylePosition::MaxBSize(
+    WritingMode aWM) const {
+  return aWM.IsVertical() ? mMaxWidth : mMaxHeight;
+}
+inline const mozilla::StyleSize& nsStylePosition::Size(
+    mozilla::LogicalAxis aAxis, WritingMode aWM) const {
+  return aAxis == mozilla::eLogicalAxisInline ? ISize(aWM) : BSize(aWM);
+}
+inline const mozilla::StyleSize& nsStylePosition::MinSize(
+    mozilla::LogicalAxis aAxis, WritingMode aWM) const {
+  return aAxis == mozilla::eLogicalAxisInline ? MinISize(aWM) : MinBSize(aWM);
+}
+inline const mozilla::StyleMaxSize& nsStylePosition::MaxSize(
+    mozilla::LogicalAxis aAxis, WritingMode aWM) const {
+  return aAxis == mozilla::eLogicalAxisInline ? MaxISize(aWM) : MaxBSize(aWM);
+}
+
+inline bool nsStylePosition::ISizeDependsOnContainer(WritingMode aWM) const {
+  const auto& iSize = ISize(aWM);
+  return iSize.IsAuto() || ISizeCoordDependsOnContainer(iSize);
+}
+inline bool nsStylePosition::MinISizeDependsOnContainer(WritingMode aWM) const {
+  // NOTE: For a flex item, "min-inline-size:auto" is supposed to behave like
+  // "min-content", which does depend on the container, so you might think we'd
+  // need a special case for "flex item && min-inline-size:auto" here. However,
+  // we don't actually need that special-case code, because flex items are
+  // explicitly supposed to *ignore* their min-inline-size (i.e. behave like
+  // it's 0) until the flex container explicitly considers it. So -- since the
+  // flex container doesn't rely on this method, we don't need to worry about
+  // special behavior for flex items' "min-inline-size:auto" values here.
+  return ISizeCoordDependsOnContainer(MinISize(aWM));
+}
+inline bool nsStylePosition::MaxISizeDependsOnContainer(WritingMode aWM) const {
+  // NOTE: The comment above MinISizeDependsOnContainer about flex items
+  // applies here, too.
+  return ISizeCoordDependsOnContainer(MaxISize(aWM));
+}
+// Note that these functions count `auto` as depending on the container
+// since that's the case for absolutely positioned elements.
+// However, some callers do not care about this case and should check
+// for it, since it is the most common case.
+// FIXME: We should probably change the assumption to be the other way
+// around.
+inline bool nsStylePosition::BSizeDependsOnContainer(WritingMode aWM) const {
+  const auto& bSize = BSize(aWM);
+  return bSize.BehavesLikeInitialValueOnBlockAxis() ||
+         BSizeCoordDependsOnContainer(bSize);
+}
+inline bool nsStylePosition::MinBSizeDependsOnContainer(WritingMode aWM) const {
+  return BSizeCoordDependsOnContainer(MinBSize(aWM));
+}
+inline bool nsStylePosition::MaxBSizeDependsOnContainer(WritingMode aWM) const {
+  return BSizeCoordDependsOnContainer(MaxBSize(aWM));
+}
+
+inline bool nsStyleMargin::HasBlockAxisAuto(mozilla::WritingMode aWM) const {
+  return mMargin.GetBStart(aWM).IsAuto() || mMargin.GetBEnd(aWM).IsAuto();
+}
+
+inline bool nsStyleMargin::HasInlineAxisAuto(mozilla::WritingMode aWM) const {
+  return mMargin.GetIStart(aWM).IsAuto() || mMargin.GetIEnd(aWM).IsAuto();
+}
+inline bool nsStyleMargin::HasAuto(mozilla::LogicalAxis aAxis,
+                                   mozilla::WritingMode aWM) const {
+  return aAxis == mozilla::eLogicalAxisInline ? HasInlineAxisAuto(aWM)
+                                              : HasBlockAxisAuto(aWM);
+}
+
+inline mozilla::StyleAlignFlags nsStylePosition::UsedSelfAlignment(
+    mozilla::LogicalAxis aAxis, const mozilla::ComputedStyle* aParent) const {
+  return aAxis == mozilla::eLogicalAxisBlock ? UsedAlignSelf(aParent)._0
+                                             : UsedJustifySelf(aParent)._0;
+}
+
+inline mozilla::StyleContentDistribution nsStylePosition::UsedContentAlignment(
+    mozilla::LogicalAxis aAxis) const {
+  return aAxis == mozilla::eLogicalAxisBlock ? mAlignContent : mJustifyContent;
+}
+
+inline mozilla::StyleContentDistribution nsStylePosition::UsedTracksAlignment(
+    mozilla::LogicalAxis aAxis, uint32_t aIndex) const {
+  using T = mozilla::StyleAlignFlags;
+  const auto& tracksAlignment =
+      aAxis == mozilla::eLogicalAxisBlock ? mAlignTracks : mJustifyTracks;
+  if (MOZ_LIKELY(tracksAlignment.IsEmpty())) {
+    // An empty array encodes the initial value, 'normal', which behaves as
+    // 'start' for Grid containers.
+    return mozilla::StyleContentDistribution{T::START};
+  }
+
+  // If there are fewer values than tracks, then the last value is used for all
+  // the remaining tracks.
+  const auto& ta = tracksAlignment.AsSpan();
+  auto align = ta[std::min<size_t>(aIndex, ta.Length() - 1)];
+  if (align.primary == T::NORMAL) {
+    align = mozilla::StyleContentDistribution{T::START};
+  }
+  return align;
+}
+
+#endif  // WritingModes_h_