tor-browser

WritingModes.h (81280B)

---

/* -*- 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/EnumSet.h"
#include "mozilla/intl/BidiEmbeddingLevel.h"
#include "nsRect.h"
#include "nsStyleStruct.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 class LogicalAxis : uint8_t {
 Block,
 Inline,
};
enum class LogicalEdge : uint8_t { Start, End };

enum class LogicalSide : uint8_t {
 BStart,
 BEnd,
 IStart,
 IEnd,
};

enum class LogicalCorner : uint8_t {
 BStartIStart,
 BStartIEnd,
 BEndIEnd,
 BEndIStart,
};

// Physical axis constants.
enum class PhysicalAxis : uint8_t { Vertical, Horizontal };

using PhysicalAxes = EnumSet<PhysicalAxis>;
static constexpr PhysicalAxes kPhysicalAxesBoth{PhysicalAxis::Vertical,
                                               PhysicalAxis::Horizontal};

inline StyleLogicalAxis ToStyleLogicalAxis(LogicalAxis aLogicalAxis) {
 return StyleLogicalAxis(aLogicalAxis == LogicalAxis::Block
                             ? StyleLogicalAxis::Block
                             : StyleLogicalAxis::Inline);
}

inline LogicalAxis GetOrthogonalAxis(LogicalAxis aAxis) {
 return aAxis == LogicalAxis::Block ? LogicalAxis::Inline : LogicalAxis::Block;
}

inline bool IsInline(LogicalSide aSide) {
 return (aSide == LogicalSide::IStart) || (aSide == LogicalSide::IEnd);
}

inline bool IsBlock(LogicalSide aSide) { return !IsInline(aSide); }

inline bool IsEnd(LogicalSide aSide) {
 return (aSide == LogicalSide::BEnd) || (aSide == LogicalSide::IEnd);
}

inline bool IsStart(LogicalSide aSide) { return !IsEnd(aSide); }

inline LogicalAxis GetAxis(LogicalSide aSide) {
 return IsInline(aSide) ? LogicalAxis::Inline : LogicalAxis::Block;
}

inline LogicalEdge GetEdge(LogicalSide aSide) {
 return IsEnd(aSide) ? LogicalEdge::End : LogicalEdge::Start;
}

inline LogicalEdge GetOppositeEdge(LogicalEdge aEdge) {
 return aEdge == LogicalEdge::Start ? LogicalEdge::End : LogicalEdge::Start;
}

inline LogicalSide MakeLogicalSide(LogicalAxis aAxis, LogicalEdge aEdge) {
 if (aAxis == LogicalAxis::Inline) {
   return aEdge == LogicalEdge::Start ? LogicalSide::IStart
                                      : LogicalSide::IEnd;
 }
 return aEdge == LogicalEdge::Start ? LogicalSide::BStart : LogicalSide::BEnd;
}

inline LogicalSide GetOppositeSide(LogicalSide aSide) {
 return MakeLogicalSide(GetAxis(aSide), GetOppositeEdge(GetEdge(aSide)));
}

enum class LineRelativeDir : uint8_t {
 Over = static_cast<uint8_t>(LogicalSide::BStart),
 Under = static_cast<uint8_t>(LogicalSide::BEnd),
 Left = static_cast<uint8_t>(LogicalSide::IStart),
 Right = static_cast<uint8_t>(LogicalSide::IEnd)
};

/**
* 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 class InlineDir : uint8_t {
   LTR,  // text flows horizontally left to right
   RTL,  // text flows horizontally right to left
   TTB,  // text flows vertically top to bottom
   BTT,  // text flows vertically bottom to top
 };

 /**
  * Absolute block flow direction
  */
 enum class BlockDir : uint8_t {
   TB,  // horizontal lines stack top to bottom
   RL,  // vertical lines stack right to left
   LR,  // vertical lines stack left to right
 };

 /**
  * Return the absolute inline flow direction as an InlineDir
  */
 InlineDir GetInlineDir() const {
   if (IsVertical()) {
     return IsInlineReversed() ? InlineDir::BTT : InlineDir::TTB;
   }
   return IsInlineReversed() ? InlineDir::RTL : InlineDir::LTR;
 }

 /**
  * Return the absolute block flow direction as a BlockDir
  */
 BlockDir GetBlockDir() const {
   if (IsVertical()) {
     return mWritingMode & StyleWritingMode::VERTICAL_LR ? BlockDir::LR
                                                         : BlockDir::RL;
   }
   return BlockDir::TB;
 }

 /**
  * 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.
  */
 bool IsBidiLTR() const { return !IsBidiRTL(); }

 /**
  * Return true if bidi direction is RTL.
  */
 bool IsBidiRTL() const { return !!(mWritingMode & StyleWritingMode::RTL); }

 /**
  * 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 GetBlockDir() == BlockDir::LR; }

 /**
  * True if vertical-mode block direction is RL (convenience method).
  */
 bool IsVerticalRL() const { return GetBlockDir() == BlockDir::RL; }

 /**
  * True if vertical writing mode, i.e. when
  * writing-mode: vertical-lr | vertical-rl | sideways-lr | sideways-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._0 & ~(StyleWritingMode::VERTICAL_SIDEWAYS |
                                          StyleWritingMode::TEXT_SIDEWAYS)
                                             ._0);
 }
#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(); }

 /**
  * Convert LogicalAxis to PhysicalAxis given the current writing mode.
  */
 mozilla::PhysicalAxis PhysicalAxis(LogicalAxis aAxis) const {
   const bool isInline = aAxis == LogicalAxis::Inline;
   return isInline == IsVertical() ? PhysicalAxis::Vertical
                                   : PhysicalAxis::Horizontal;
 }

 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][static_cast<uint8_t>(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.
   static_assert(StyleWritingMode::VERTICAL._0 == 0x01 &&
                     StyleWritingMode::INLINE_REVERSED._0 == 0x02 &&
                     StyleWritingMode::VERTICAL_LR._0 == 0x04 &&
                     StyleWritingMode::LINE_INVERTED._0 == 0x08,
                 "Unexpected values for StyleWritingMode constants!");
   uint8_t index = mWritingMode._0 & 0x0F;
   return kLogicalInlineSides[index][static_cast<uint8_t>(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)) {
     static_assert(StyleWritingMode::VERTICAL._0 == 0x01 &&
                       StyleWritingMode::VERTICAL_LR._0 == 0x04,
                   "Unexpected values for StyleWritingMode constants!");
     const uint8_t wm =
         ((mWritingMode & StyleWritingMode::VERTICAL_LR)._0 >> 1) |
         (mWritingMode & StyleWritingMode::VERTICAL)._0;
     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
     { LogicalSide::BStart, LogicalSide::IEnd,
       LogicalSide::BEnd,   LogicalSide::IStart },  // horizontal-tb         ltr
     { LogicalSide::IStart, LogicalSide::BStart,
       LogicalSide::IEnd,   LogicalSide::BEnd   },  // vertical-rl           ltr
     { LogicalSide::BStart, LogicalSide::IStart,
       LogicalSide::BEnd,   LogicalSide::IEnd   },  // horizontal-tb         rtl
     { LogicalSide::IEnd,   LogicalSide::BStart,
       LogicalSide::IStart, LogicalSide::BEnd   },  // vertical-rl           rtl
     { LogicalSide::BEnd,   LogicalSide::IStart,
       LogicalSide::BStart, LogicalSide::IEnd   },  // (horizontal-bt) (inv) ltr
     { LogicalSide::IStart, LogicalSide::BEnd,
       LogicalSide::IEnd,   LogicalSide::BStart },  // vertical-lr   sw-left rtl
     { LogicalSide::BEnd,   LogicalSide::IEnd,
       LogicalSide::BStart, LogicalSide::IStart },  // (horizontal-bt) (inv) rtl
     { LogicalSide::IEnd,   LogicalSide::BEnd,
       LogicalSide::IStart, LogicalSide::BStart },  // vertical-lr   sw-left ltr
     { LogicalSide::BStart, LogicalSide::IEnd,
       LogicalSide::BEnd,   LogicalSide::IStart },  // horizontal-tb   (inv) rtl
     { LogicalSide::IStart, LogicalSide::BStart,
       LogicalSide::IEnd,   LogicalSide::BEnd   },  // vertical-rl   sw-left rtl
     { LogicalSide::BStart, LogicalSide::IStart,
       LogicalSide::BEnd,   LogicalSide::IEnd   },  // horizontal-tb   (inv) ltr
     { LogicalSide::IEnd,   LogicalSide::BStart,
       LogicalSide::IStart, LogicalSide::BEnd   },  // vertical-rl   sw-left ltr
     { LogicalSide::BEnd,   LogicalSide::IEnd,
       LogicalSide::BStart, LogicalSide::IStart },  // (horizontal-bt)       ltr
     { LogicalSide::IStart, LogicalSide::BEnd,
       LogicalSide::IEnd,   LogicalSide::BStart },  // vertical-lr           ltr
     { LogicalSide::BEnd,   LogicalSide::IStart,
       LogicalSide::BStart, LogicalSide::IEnd   },  // (horizontal-bt)       rtl
     { LogicalSide::IEnd,   LogicalSide::BEnd,
       LogicalSide::IStart, LogicalSide::BStart },  // vertical-lr           rtl
   };
   // clang-format on

   static_assert(StyleWritingMode::VERTICAL._0 == 0x01 &&
                     StyleWritingMode::INLINE_REVERSED._0 == 0x02 &&
                     StyleWritingMode::VERTICAL_LR._0 == 0x04 &&
                     StyleWritingMode::LINE_INVERTED._0 == 0x08,
                 "Unexpected values for StyleWritingMode constants!");
   uint8_t index = mWritingMode._0 & 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);
 }

 /**
  * Construct a default WritingMode, equivalent to specifying
  * 'writing-mode: horizontal-tb' and 'direction: ltr' in CSS.
  */
 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();
 }

 inline StyleWritingMode ToStyleWritingMode() const {
   return StyleWritingMode(GetBits());
 }

 /**
  * 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.
  */
 void SetDirectionFromBidiLevel(mozilla::intl::BidiEmbeddingLevel level) {
   if (level.IsRTL() == IsBidiLTR()) {
     mWritingMode ^= StyleWritingMode::RTL | StyleWritingMode::INLINE_REVERSED;
   }
 }

 /**
  * Compare two WritingModes for equality.
  */
 bool operator==(const WritingMode&) const = default;
 bool operator!=(const WritingMode&) const = default;

 /**
  * Check whether two modes are orthogonal to each other.
  */
 bool IsOrthogonalTo(const WritingMode& aOther) const {
   return IsVertical() != aOther.IsVertical();
 }

 /**
  * Convert aAxis in current writing mode to the axis in aToMode.
  */
 LogicalAxis ConvertAxisTo(LogicalAxis aAxis, WritingMode aToMode) const {
   return IsOrthogonalTo(aToMode) ? GetOrthogonalAxis(aAxis) : aAxis;
 }

 /**
  * 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 {
   if (MOZ_LIKELY(*this == aOther)) {
     // Dedicated short circuit for the common case.
     return true;
   }

   mozilla::Side myStartSide =
       this->PhysicalSide(MakeLogicalSide(aLogicalAxis, LogicalEdge::Start));

   // Figure out which of aOther's axes is parallel to |this| WritingMode's
   // aLogicalAxis, and get its physical start side as well.
   const LogicalAxis otherWMAxis = ConvertAxisTo(aLogicalAxis, aOther);
   mozilla::Side otherWMStartSide =
       aOther.PhysicalSide(MakeLogicalSide(otherWMAxis, LogicalEdge::Start));

   NS_ASSERTION(myStartSide % 2 == otherWMStartSide % 2,
                "Should end up with sides in the same physical axis");
   return myStartSide == otherWMStartSide;
 }

 /**
  * Determine a writing mode for determining the line-over/line-under side of a
  * box to use for baseline alignment, based on the container and item's
  * writing modes and the alignment axis.
  *
  * See: https://drafts.csswg.org/css-align-3/#baseline-export
  *
  * @param aContainerWM writing mode of the container (alignment context).
  * @param aItemWM writing mode of the item being aligned.
  * @param aAlignmentAxis axis of alignment, in the container’s writing mode.
  *        LogicalAxis::Inline (rows) for align-{items,self}:[last] baseline.
  *        LogicalAxis::Block (columns) for justify-{items,self}:[last]
  *        baseline.
  */
 static WritingMode DetermineWritingModeForBaselineSynthesis(
     const WritingMode& aContainerWM, const WritingMode& aItemWM,
     LogicalAxis aAlignmentAxis) {
   // Use the physical alignment axis for comparison:
   auto physicalAlignmentAxis = aContainerWM.PhysicalAxis(aAlignmentAxis);

   // If the item's block flow direction is orthogonal to the alignment axis,
   // use its writing mode.
   auto itemAxis = aItemWM.PhysicalAxis(LogicalAxis::Block);
   if (itemAxis != physicalAlignmentAxis) {
     return aItemWM;
   }

   // If the container's block flow direction is orthogonal to the alignment
   // axis, use its writing mode.
   auto containerAxis = aContainerWM.PhysicalAxis(LogicalAxis::Block);
   if (containerAxis != physicalAlignmentAxis) {
     return aContainerWM;
   }

   // If not using the item or container writing mode, synthesize an
   // axis-compatible writing mode based on the container's writing mode.
   //
   // From https://drafts.csswg.org/css-align-3/#baseline-export:
   //
   // - If the box’s own writing mode is vertical, assume `horizontal-tb`.
   // - If the box’s own writing mode is horizontal, assume `vertical-lr` if
   //   direction is `ltr` and `vertical-rl` if direction is `rtl`.

   if (aContainerWM.IsVertical()) {
     return WritingMode{StyleWritingMode::WRITING_MODE_HORIZONTAL_TB._0};
   }

   return (aContainerWM.IsBidiLTR())
              ? WritingMode{StyleWritingMode::WRITING_MODE_VERTICAL_LR._0}
              : WritingMode{StyleWritingMode::WRITING_MODE_VERTICAL_RL._0};
 }

 uint8_t GetBits() const { return mWritingMode._0; }

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;

 /**
  * Unknown writing mode (should never actually be stored or used anywhere).
  */
 static constexpr uint8_t kUnknownWritingMode = 0xff;

 /**
  * Return a WritingMode representing an unknown value.
  */
 static inline WritingMode Unknown() {
   return WritingMode(kUnknownWritingMode);
 }

 /**
  * Constructing a WritingMode with an arbitrary value is a private operation.
  * This is currently only used by the Unknown() and IgnoreSideways() methods,
  * and a friend struct IMENotification.
  */
 explicit WritingMode(uint8_t aValue) : mWritingMode{aValue} {}

 StyleWritingMode mWritingMode;
};

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 == LogicalAxis::Inline ? 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 == LogicalAxis::Inline ? 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);
 }

 /**
  * Considering 'this' LogicalPoint as the origin of some rect, as expressed
  * in writing mode aFromMode: this method returns the origin of that same
  * rect, as expressed in writing mode aToMode.
  *
  * The two points ('this' and the return value) may correspond to *different*
  * physical corners of the rect.  Each point is using its own writing-mode
  * to determine which corner is the origin.
  *
  * @param aToMode The writing mode to use for the return value.
  * @param aFromMode The writing mode for 'this' LogicalPoint.
  * @param aRectSize The physical size of the rectangle whose origin
  *                  is being requested.
  * @param aContainerSize The physical size of the container that defines the
  *                       local coordinate space.  (Our points' coordinates are
  *                       relative to the bounds of this container.)
  */
 LogicalPoint ConvertRectOriginTo(WritingMode aToMode, WritingMode aFromMode,
                                  const nsSize& aRectSize,
                                  const nsSize& aContainerSize) const {
   CHECK_WRITING_MODE(aFromMode);
   if (aFromMode == aToMode) {
     return *this;
   }

   // Note: this might *look* like it's abusing ConvertTo(), since the last
   // param to ConvertTo() is named as if it's just a container-size rather
   // than the difference-in-sizes that we're passing here.  But this calling
   // pattern is actually correct for what we're trying to do here.
   //
   // Conceptually, ConvertTo()'s aContainerSize param just represents how
   // much extra space the container has *around* the converted thing in each
   // physical axis. When we're just converting a LogicalPoint with zero
   // thickness -- the way ConvertTo() expects to be called -- the extra space
   // around it in its container is simply the container size. But here, we're
   // converting the origin of a *rect*, and the rect has some
   // potentially-nonzero-thickness; so here, the extra space is the
   // container's size *minus* the rect's size.
   return ConvertTo(aToMode, aFromMode, aContainerSize - aRectSize);
 }

 bool operator==(const LogicalPoint& aOther) const {
   CHECK_WRITING_MODE(aOther.GetWritingMode());
   return mPoint == aOther.mPoint;
 }
 bool operator!=(const LogicalPoint&) const = default;

 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 WritingMode::Unknown())
   // 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 WritingMode::Unknown())
   // 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
  * WritingMode::Unknown(), 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 == LogicalAxis::Inline ? 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 == LogicalAxis::Inline ? 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 IsAllValues(0); }
 bool IsAllValues(nscoord aValue) const {
   return ISize() == aValue && BSize() == aValue;
 }

 /**
  * 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&) const = default;

 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 {
 static constexpr EnumSet<LogicalSide> BBoth{LogicalSide::BStart,
                                             LogicalSide::BEnd};
 static constexpr EnumSet<LogicalSide> IBoth{LogicalSide::IStart,
                                             LogicalSide::IEnd};
 static constexpr EnumSet<LogicalSide> All{
     LogicalSide::BStart, LogicalSide::BEnd, LogicalSide::IStart,
     LogicalSide::IEnd};

 explicit LogicalSides(WritingMode aWritingMode)
#ifdef DEBUG
     : mWritingMode(aWritingMode)
#endif
 {
 }
 LogicalSides(WritingMode aWritingMode, LogicalSides aSides)
     :
#ifdef DEBUG
       mWritingMode(aWritingMode),
#endif
       mSides(aSides.mSides) {
 }
 LogicalSides(WritingMode aWritingMode, EnumSet<LogicalSide> aSides)
     :
#ifdef DEBUG
       mWritingMode(aWritingMode),
#endif
       mSides(aSides) {
 }
 bool IsEmpty() const { return mSides.isEmpty(); }
 bool BStart() const { return mSides.contains(LogicalSide::BStart); }
 bool BEnd() const { return mSides.contains(LogicalSide::BEnd); }
 bool IStart() const { return mSides.contains(LogicalSide::IStart); }
 bool IEnd() const { return mSides.contains(LogicalSide::IEnd); }
 bool Contains(LogicalSide aSide) const { return mSides.contains(aSide); }
 LogicalSides& operator+=(LogicalSides aOther) {
   mSides += aOther.mSides;
   return *this;
 }
 LogicalSides& operator+=(LogicalSide aOther) {
   mSides += aOther;
   return *this;
 }
 bool operator==(const LogicalSides& aOther) const {
   CHECK_WRITING_MODE(aOther.GetWritingMode());
   return mSides == aOther.mSides;
 }
 bool operator!=(const LogicalSides&) const = default;

#ifdef DEBUG
 WritingMode GetWritingMode() const { return mWritingMode; }
#else
 WritingMode GetWritingMode() const { return WritingMode::Unknown(); }
#endif

private:
#ifdef DEBUG
 WritingMode mWritingMode;
#endif
 EnumSet<LogicalSide> mSides;
};

/**
* 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 == LogicalAxis::Inline ? IStart(aWM) : BStart(aWM);
 }
 nscoord End(LogicalAxis aAxis, WritingMode aWM) const {
   return aAxis == LogicalAxis::Inline ? 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 == LogicalAxis::Inline ? IStart(aWM) : BStart(aWM);
 }
 nscoord& End(LogicalAxis aAxis, WritingMode aWM) {
   return aAxis == LogicalAxis::Inline ? 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 == LogicalAxis::Inline ? IStartEnd(aWM) : BStartEnd(aWM);
 }

 nscoord Side(LogicalSide aSide, WritingMode aWM) const {
   switch (aSide) {
     case LogicalSide::BStart:
       return BStart(aWM);
     case LogicalSide::BEnd:
       return BEnd(aWM);
     case LogicalSide::IStart:
       return IStart(aWM);
     case LogicalSide::IEnd:
       return IEnd(aWM);
   }

   MOZ_ASSERT_UNREACHABLE("We should handle all sides!");
   return BStart(aWM);
 }
 nscoord& Side(LogicalSide aSide, WritingMode aWM) {
   switch (aSide) {
     case LogicalSide::BStart:
       return BStart(aWM);
     case LogicalSide::BEnd:
       return BEnd(aWM);
     case LogicalSide::IStart:
       return IStart(aWM);
     case LogicalSide::IEnd:
       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());
 }

 /**
  * Return a LogicalPoint representing an offset to the start-sides, i.e.
  * inline-start and block-start.
  */
 LogicalPoint StartOffset(WritingMode aWritingMode) const {
   CHECK_WRITING_MODE(aWritingMode);
   return LogicalPoint(aWritingMode, IStart(), BStart());
 }

 /**
  * 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.IsAllZero(); }

 bool operator==(const LogicalMargin& aMargin) const {
   CHECK_WRITING_MODE(aMargin.GetWritingMode());
   return mMargin == aMargin.mMargin;
 }
 bool operator!=(const LogicalMargin&) const = default;

 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 == LogicalAxis::Inline ? IStart(aWM) : BStart(aWM);
 }
 nscoord End(LogicalAxis aAxis, WritingMode aWM) const {
   return aAxis == LogicalAxis::Inline ? IEnd(aWM) : BEnd(aWM);
 }
 nscoord Size(LogicalAxis aAxis, WritingMode aWM) const {
   return aAxis == LogicalAxis::Inline ? 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 == LogicalAxis::Inline ? IStart(aWM) : BStart(aWM);
 }
 nscoord& Size(LogicalAxis aAxis, WritingMode aWM) {
   return aAxis == LogicalAxis::Inline ? 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(LogicalSide aSide, WritingMode aWM) const {
 return Get(aWM.PhysicalSide(aSide));
}

template <typename T>
const T& StyleRect<T>::GetIStart(WritingMode aWM) const {
 return Get(LogicalSide::IStart, aWM);
}

template <typename T>
const T& StyleRect<T>::GetBStart(WritingMode aWM) const {
 return Get(LogicalSide::BStart, aWM);
}

template <typename T>
const T& StyleRect<T>::GetIEnd(WritingMode aWM) const {
 return Get(LogicalSide::IEnd, aWM);
}

template <typename T>
const T& StyleRect<T>::GetBEnd(WritingMode aWM) const {
 return Get(LogicalSide::BEnd, aWM);
}

template <typename T>
T& StyleRect<T>::Get(LogicalSide aSide, WritingMode aWM) {
 return Get(aWM.PhysicalSide(aSide));
}

template <typename T>
T& StyleRect<T>::GetIStart(WritingMode aWM) {
 return Get(LogicalSide::IStart, aWM);
}

template <typename T>
T& StyleRect<T>::GetBStart(WritingMode aWM) {
 return Get(LogicalSide::BStart, aWM);
}

template <typename T>
T& StyleRect<T>::GetIEnd(WritingMode aWM) {
 return Get(LogicalSide::IEnd, aWM);
}

template <typename T>
T& StyleRect<T>::GetBEnd(WritingMode aWM) {
 return Get(LogicalSide::BEnd, aWM);
}

template <typename T>
const T& StyleRect<T>::Start(mozilla::LogicalAxis aAxis,
                            mozilla::WritingMode aWM) const {
 return aAxis == LogicalAxis::Inline ? GetIStart(aWM) : GetBStart(aWM);
}

template <typename T>
const T& StyleRect<T>::End(mozilla::LogicalAxis aAxis,
                          mozilla::WritingMode aWM) const {
 return aAxis == LogicalAxis::Inline ? GetIEnd(aWM) : GetBEnd(aWM);
}

inline AspectRatio AspectRatio::ConvertToWritingMode(
   const WritingMode& aWM) const {
 return aWM.IsVertical() ? Inverted() : *this;
}

template <>
inline bool StyleSize::BehavesLikeInitialValue(LogicalAxis aAxis) const {
 return aAxis == LogicalAxis::Inline ? IsAuto()
                                     : BehavesLikeInitialValueOnBlockAxis();
}

template <>
inline bool StyleMaxSize::BehavesLikeInitialValue(LogicalAxis aAxis) const {
 return aAxis == LogicalAxis::Inline ? IsNone()
                                     : BehavesLikeInitialValueOnBlockAxis();
}

}  // namespace mozilla

// Definitions of inline methods for nsStylePosition, declared in
// nsStyleStruct.h but not defined there because they need WritingMode.
inline AnchorResolvedInset nsStylePosition::GetAnchorResolvedInset(
   mozilla::LogicalSide aSide, WritingMode aWM,
   const AnchorPosOffsetResolutionParams& aParams) const {
 return GetAnchorResolvedInset(aWM.PhysicalSide(aSide), aParams);
}

inline mozilla::Maybe<mozilla::Side> nsStylePosition::GetSingleAutoInsetInAxis(
   LogicalAxis aAxis, WritingMode aWM,
   const AnchorPosOffsetResolutionParams& aParams) const {
 const bool isInlineAxis = (aAxis == LogicalAxis::Inline);
 const mozilla::StylePhysicalAxis physicalAxis =
     (isInlineAxis == aWM.IsVertical())
         ? mozilla::StylePhysicalAxis::Vertical
         : mozilla::StylePhysicalAxis::Horizontal;
 return GetSingleAutoInsetInAxis(physicalAxis, aParams);
}

inline AnchorResolvedSize nsStylePosition::ISize(
   WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return aWM.IsVertical() ? GetHeight(aParams) : GetWidth(aParams);
}

inline AnchorResolvedSize nsStylePosition::MinISize(
   WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return aWM.IsVertical() ? GetMinHeight(aParams) : GetMinWidth(aParams);
}

inline AnchorResolvedMaxSize nsStylePosition::MaxISize(
   WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return aWM.IsVertical() ? GetMaxHeight(aParams) : GetMaxWidth(aParams);
}

inline AnchorResolvedSize nsStylePosition::BSize(
   WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return aWM.IsVertical() ? GetWidth(aParams) : GetHeight(aParams);
}

inline AnchorResolvedSize nsStylePosition::MinBSize(
   WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return aWM.IsVertical() ? GetMinWidth(aParams) : GetMinHeight(aParams);
}

inline AnchorResolvedMaxSize nsStylePosition::MaxBSize(
   WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return aWM.IsVertical() ? GetMaxWidth(aParams) : GetMaxHeight(aParams);
}

inline AnchorResolvedSize nsStylePosition::Size(
   mozilla::LogicalAxis aAxis, WritingMode aWM,
   const AnchorPosResolutionParams& aParams) const {
 return aAxis == mozilla::LogicalAxis::Inline ? ISize(aWM, aParams)
                                              : BSize(aWM, aParams);
}

inline AnchorResolvedSize nsStylePosition::MinSize(
   mozilla::LogicalAxis aAxis, WritingMode aWM,
   const AnchorPosResolutionParams& aParams) const {
 return aAxis == mozilla::LogicalAxis::Inline ? MinISize(aWM, aParams)
                                              : MinBSize(aWM, aParams);
}

inline AnchorResolvedMaxSize nsStylePosition::MaxSize(
   mozilla::LogicalAxis aAxis, mozilla::WritingMode aWM,
   const AnchorPosResolutionParams& aParams) const {
 return aAxis == mozilla::LogicalAxis::Inline ? MaxISize(aWM, aParams)
                                              : MaxBSize(aWM, aParams);
}

inline bool nsStylePosition::ISizeDependsOnContainer(
   const AnchorResolvedSize& aSize) {
 return aSize->IsAuto() || ISizeCoordDependsOnContainer(*aSize);
}

inline bool nsStylePosition::MinISizeDependsOnContainer(
   const AnchorResolvedSize& aSize) {
 // 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(*aSize);
}

inline bool nsStylePosition::MaxISizeDependsOnContainer(
   const AnchorResolvedMaxSize& aSize) {
 // NOTE: The comment above MinISizeDependsOnContainer about flex items
 // applies here, too.
 return ISizeCoordDependsOnContainer(*aSize);
}

// 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(
   const AnchorResolvedSize& aSize) {
 return aSize->BehavesLikeInitialValueOnBlockAxis() ||
        BSizeCoordDependsOnContainer(*aSize);
}

inline bool nsStylePosition::MinBSizeDependsOnContainer(
   const AnchorResolvedSize& aSize) {
 return BSizeCoordDependsOnContainer(*aSize);
}

inline bool nsStylePosition::MaxBSizeDependsOnContainer(
   const AnchorResolvedMaxSize& aSize) {
 return BSizeCoordDependsOnContainer(*aSize);
}

inline bool nsStyleMargin::HasBlockAxisAuto(
   mozilla::WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return GetMargin(mozilla::LogicalSide::BStart, aWM, aParams)->IsAuto() ||
        GetMargin(mozilla::LogicalSide::BEnd, aWM, aParams)->IsAuto();
}

inline bool nsStyleMargin::HasInlineAxisAuto(
   mozilla::WritingMode aWM, const AnchorPosResolutionParams& aParams) const {
 return GetMargin(mozilla::LogicalSide::IStart, aWM, aParams)->IsAuto() ||
        GetMargin(mozilla::LogicalSide::IEnd, aWM, aParams)->IsAuto();
}

inline bool nsStyleMargin::HasAuto(
   mozilla::LogicalAxis aAxis, mozilla::WritingMode aWM,
   const AnchorPosResolutionParams& aParams) const {
 return aAxis == mozilla::LogicalAxis::Inline ? HasInlineAxisAuto(aWM, aParams)
                                              : HasBlockAxisAuto(aWM, aParams);
}

inline AnchorResolvedMargin nsStyleMargin::GetMargin(
   mozilla::LogicalSide aSide, mozilla::WritingMode aWM,
   const AnchorPosResolutionParams& aParams) const {
 return GetMargin(aWM.PhysicalSide(aSide), aParams);
}

inline mozilla::StyleAlignFlags nsStylePosition::UsedSelfAlignment(
   LogicalAxis aAlignContainerAxis,
   const ComputedStyle* aAlignContainerStyle) const {
 return aAlignContainerAxis == LogicalAxis::Block
            ? UsedAlignSelf(aAlignContainerStyle)._0
            : UsedJustifySelf(aAlignContainerStyle)._0;
}

inline mozilla::StyleAlignFlags nsStylePosition::UsedSelfAlignment(
   WritingMode aAlignSubjectWM, LogicalAxis aAlignSubjectAxis,
   WritingMode aAlignContainerWM,
   const ComputedStyle* aAlignContainerStyle) const {
 const auto alignContainerAxis =
     aAlignSubjectWM.ConvertAxisTo(aAlignSubjectAxis, aAlignContainerWM);
 return UsedSelfAlignment(alignContainerAxis, aAlignContainerStyle);
}

inline mozilla::StyleContentDistribution nsStylePosition::UsedContentAlignment(
   mozilla::LogicalAxis aAxis) const {
 return aAxis == mozilla::LogicalAxis::Block ? mAlignContent : mJustifyContent;
}

inline mozilla::UsedFloat nsStyleDisplay::UsedFloat(
   mozilla::WritingMode aCBWM) const {
 switch (mFloat) {
   case mozilla::StyleFloat::None:
     return mozilla::UsedFloat::None;
   case mozilla::StyleFloat::Left:
     return mozilla::UsedFloat::Left;
   case mozilla::StyleFloat::Right:
     return mozilla::UsedFloat::Right;
   case mozilla::StyleFloat::InlineStart:
     return aCBWM.IsBidiLTR() ? mozilla::UsedFloat::Left
                              : mozilla::UsedFloat::Right;
   case mozilla::StyleFloat::InlineEnd:
     return aCBWM.IsBidiLTR() ? mozilla::UsedFloat::Right
                              : mozilla::UsedFloat::Left;
 }
 MOZ_ASSERT_UNREACHABLE("all cases are handled above!");
 return mozilla::UsedFloat::None;
}

inline mozilla::UsedClear nsStyleDisplay::UsedClear(
   mozilla::WritingMode aCBWM) const {
 switch (mClear) {
   case mozilla::StyleClear::None:
     return mozilla::UsedClear::None;
   case mozilla::StyleClear::Left:
     return mozilla::UsedClear::Left;
   case mozilla::StyleClear::Right:
     return mozilla::UsedClear::Right;
   case mozilla::StyleClear::Both:
     return mozilla::UsedClear::Both;
   case mozilla::StyleClear::InlineStart:
     return aCBWM.IsBidiLTR() ? mozilla::UsedClear::Left
                              : mozilla::UsedClear::Right;
   case mozilla::StyleClear::InlineEnd:
     return aCBWM.IsBidiLTR() ? mozilla::UsedClear::Right
                              : mozilla::UsedClear::Left;
 }
 MOZ_ASSERT_UNREACHABLE("all cases are handled above!");
 return mozilla::UsedClear::None;
}

#endif  // WritingModes_h_