layout/base/Units.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef MOZ_UNITS_H_
   8 #define MOZ_UNITS_H_
   9
  10 #include <type_traits>
  11
  12 #include "mozilla/gfx/Coord.h"
  13 #include "mozilla/gfx/Point.h"
  14 #include "mozilla/gfx/Rect.h"
  15 #include "mozilla/gfx/RectAbsolute.h"
  16 #include "mozilla/gfx/ScaleFactor.h"
  17 #include "mozilla/gfx/ScaleFactors2D.h"
  18 #include "nsMargin.h"
  19 #include "nsRect.h"
  20 #include "nsRegion.h"
  21 #include "mozilla/AppUnits.h"
  22
  23 namespace mozilla {
  24
  25 template <typename T>
  26 struct IsPixel : std::false_type {};
  27
  28 // See struct declaration for a description of each unit type.
  29 struct CSSPixel;
  30 struct OuterCSSPixel;
  31 struct LayoutDevicePixel;
  32 struct LayerPixel;
  33 struct CSSTransformedLayerPixel;
  34 struct RenderTargetPixel;
  35 struct ScreenPixel;
  36 struct ParentLayerPixel;
  37 struct DesktopPixel;
  38 struct ImagePixel;
  39 struct ExternalPixel;
  40
  41 template <>
  42 struct IsPixel<CSSPixel> : std::true_type {};
  43 template <>
  44 struct IsPixel<OuterCSSPixel> : std::true_type {};
  45 template <>
  46 struct IsPixel<LayoutDevicePixel> : std::true_type {};
  47 template <>
  48 struct IsPixel<LayerPixel> : std::true_type {};
  49 template <>
  50 struct IsPixel<CSSTransformedLayerPixel> : std::true_type {};
  51 template <>
  52 struct IsPixel<RenderTargetPixel> : std::true_type {};
  53 template <>
  54 struct IsPixel<ImagePixel> : std::true_type {};
  55 template <>
  56 struct IsPixel<ScreenPixel> : std::true_type {};
  57 template <>
  58 struct IsPixel<ParentLayerPixel> : std::true_type {};
  59 template <>
  60 struct IsPixel<DesktopPixel> : std::true_type {};
  61 template <>
  62 struct IsPixel<ExternalPixel> : std::true_type {};
  63
  64 typedef gfx::CoordTyped<CSSPixel> CSSCoord;
  65 typedef gfx::IntCoordTyped<CSSPixel> CSSIntCoord;
  66 typedef gfx::PointTyped<CSSPixel> CSSPoint;
  67 typedef gfx::IntPointTyped<CSSPixel> CSSIntPoint;
  68 typedef gfx::SizeTyped<CSSPixel> CSSSize;
  69 typedef gfx::IntSizeTyped<CSSPixel> CSSIntSize;
  70 typedef gfx::RectTyped<CSSPixel> CSSRect;
  71 typedef gfx::IntRectTyped<CSSPixel> CSSIntRect;
  72 typedef gfx::MarginTyped<CSSPixel> CSSMargin;
  73 typedef gfx::IntMarginTyped<CSSPixel> CSSIntMargin;
  74 typedef gfx::IntRegionTyped<CSSPixel> CSSIntRegion;
  75
  76 typedef gfx::CoordTyped<OuterCSSPixel> OuterCSSCoord;
  77 typedef gfx::IntCoordTyped<OuterCSSPixel> OuterCSSIntCoord;
  78 typedef gfx::PointTyped<OuterCSSPixel> OuterCSSPoint;
  79 typedef gfx::IntPointTyped<OuterCSSPixel> OuterCSSIntPoint;
  80 typedef gfx::SizeTyped<OuterCSSPixel> OuterCSSSize;
  81 typedef gfx::IntSizeTyped<OuterCSSPixel> OuterCSSIntSize;
  82 typedef gfx::RectTyped<OuterCSSPixel> OuterCSSRect;
  83 typedef gfx::IntRectTyped<OuterCSSPixel> OuterCSSIntRect;
  84 typedef gfx::MarginTyped<OuterCSSPixel> OuterCSSMargin;
  85 typedef gfx::IntMarginTyped<OuterCSSPixel> OuterCSSIntMargin;
  86 typedef gfx::IntRegionTyped<OuterCSSPixel> OuterCSSIntRegion;
  87
  88 typedef gfx::CoordTyped<LayoutDevicePixel> LayoutDeviceCoord;
  89 typedef gfx::IntCoordTyped<LayoutDevicePixel> LayoutDeviceIntCoord;
  90 typedef gfx::PointTyped<LayoutDevicePixel> LayoutDevicePoint;
  91 typedef gfx::IntPointTyped<LayoutDevicePixel> LayoutDeviceIntPoint;
  92 typedef gfx::SizeTyped<LayoutDevicePixel> LayoutDeviceSize;
  93 typedef gfx::IntSizeTyped<LayoutDevicePixel> LayoutDeviceIntSize;
  94 typedef gfx::RectTyped<LayoutDevicePixel> LayoutDeviceRect;
  95 typedef gfx::IntRectTyped<LayoutDevicePixel> LayoutDeviceIntRect;
  96 typedef gfx::MarginTyped<LayoutDevicePixel> LayoutDeviceMargin;
  97 typedef gfx::IntMarginTyped<LayoutDevicePixel> LayoutDeviceIntMargin;
  98 typedef gfx::IntRegionTyped<LayoutDevicePixel> LayoutDeviceIntRegion;
  99
 100 typedef gfx::CoordTyped<LayerPixel> LayerCoord;
 101 typedef gfx::IntCoordTyped<LayerPixel> LayerIntCoord;
 102 typedef gfx::PointTyped<LayerPixel> LayerPoint;
 103 typedef gfx::IntPointTyped<LayerPixel> LayerIntPoint;
 104 typedef gfx::SizeTyped<LayerPixel> LayerSize;
 105 typedef gfx::IntSizeTyped<LayerPixel> LayerIntSize;
 106 typedef gfx::RectTyped<LayerPixel> LayerRect;
 107 typedef gfx::RectAbsoluteTyped<LayerPixel> LayerRectAbsolute;
 108 typedef gfx::IntRectTyped<LayerPixel> LayerIntRect;
 109 typedef gfx::MarginTyped<LayerPixel> LayerMargin;
 110 typedef gfx::IntMarginTyped<LayerPixel> LayerIntMargin;
 111 typedef gfx::IntRegionTyped<LayerPixel> LayerIntRegion;
 112
 113 typedef gfx::CoordTyped<CSSTransformedLayerPixel> CSSTransformedLayerCoord;
 114 typedef gfx::IntCoordTyped<CSSTransformedLayerPixel>
 115     CSSTransformedLayerIntCoord;
 116 typedef gfx::PointTyped<CSSTransformedLayerPixel> CSSTransformedLayerPoint;
 117 typedef gfx::IntPointTyped<CSSTransformedLayerPixel>
 118     CSSTransformedLayerIntPoint;
 119 typedef gfx::SizeTyped<CSSTransformedLayerPixel> CSSTransformedLayerSize;
 120 typedef gfx::IntSizeTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntSize;
 121 typedef gfx::RectTyped<CSSTransformedLayerPixel> CSSTransformedLayerRect;
 122 typedef gfx::IntRectTyped<CSSTransformedLayerPixel> CSSTransformedLayerIntRect;
 123 typedef gfx::MarginTyped<CSSTransformedLayerPixel> CSSTransformedLayerMargin;
 124 typedef gfx::IntMarginTyped<CSSTransformedLayerPixel>
 125     CSSTransformedLayerIntMargin;
 126 typedef gfx::IntRegionTyped<CSSTransformedLayerPixel>
 127     CSSTransformedLayerIntRegion;
 128
 129 typedef gfx::PointTyped<RenderTargetPixel> RenderTargetPoint;
 130 typedef gfx::IntPointTyped<RenderTargetPixel> RenderTargetIntPoint;
 131 typedef gfx::SizeTyped<RenderTargetPixel> RenderTargetSize;
 132 typedef gfx::IntSizeTyped<RenderTargetPixel> RenderTargetIntSize;
 133 typedef gfx::RectTyped<RenderTargetPixel> RenderTargetRect;
 134 typedef gfx::IntRectTyped<RenderTargetPixel> RenderTargetIntRect;
 135 typedef gfx::MarginTyped<RenderTargetPixel> RenderTargetMargin;
 136 typedef gfx::IntMarginTyped<RenderTargetPixel> RenderTargetIntMargin;
 137 typedef gfx::IntRegionTyped<RenderTargetPixel> RenderTargetIntRegion;
 138
 139 typedef gfx::PointTyped<ImagePixel> ImagePoint;
 140 typedef gfx::IntPointTyped<ImagePixel> ImageIntPoint;
 141 typedef gfx::SizeTyped<ImagePixel> ImageSize;
 142 typedef gfx::IntSizeTyped<ImagePixel> ImageIntSize;
 143 typedef gfx::RectTyped<ImagePixel> ImageRect;
 144 typedef gfx::IntRectTyped<ImagePixel> ImageIntRect;
 145
 146 typedef gfx::CoordTyped<ScreenPixel> ScreenCoord;
 147 typedef gfx::IntCoordTyped<ScreenPixel> ScreenIntCoord;
 148 typedef gfx::PointTyped<ScreenPixel> ScreenPoint;
 149 typedef gfx::IntPointTyped<ScreenPixel> ScreenIntPoint;
 150 typedef gfx::SizeTyped<ScreenPixel> ScreenSize;
 151 typedef gfx::IntSizeTyped<ScreenPixel> ScreenIntSize;
 152 typedef gfx::RectTyped<ScreenPixel> ScreenRect;
 153 typedef gfx::IntRectTyped<ScreenPixel> ScreenIntRect;
 154 typedef gfx::MarginTyped<ScreenPixel> ScreenMargin;
 155 typedef gfx::IntMarginTyped<ScreenPixel> ScreenIntMargin;
 156 typedef gfx::IntRegionTyped<ScreenPixel> ScreenIntRegion;
 157
 158 typedef gfx::CoordTyped<ParentLayerPixel> ParentLayerCoord;
 159 typedef gfx::IntCoordTyped<ParentLayerPixel> ParentLayerIntCoord;
 160 typedef gfx::PointTyped<ParentLayerPixel> ParentLayerPoint;
 161 typedef gfx::IntPointTyped<ParentLayerPixel> ParentLayerIntPoint;
 162 typedef gfx::SizeTyped<ParentLayerPixel> ParentLayerSize;
 163 typedef gfx::IntSizeTyped<ParentLayerPixel> ParentLayerIntSize;
 164 typedef gfx::RectTyped<ParentLayerPixel> ParentLayerRect;
 165 typedef gfx::IntRectTyped<ParentLayerPixel> ParentLayerIntRect;
 166 typedef gfx::MarginTyped<ParentLayerPixel> ParentLayerMargin;
 167 typedef gfx::IntMarginTyped<ParentLayerPixel> ParentLayerIntMargin;
 168 typedef gfx::IntRegionTyped<ParentLayerPixel> ParentLayerIntRegion;
 169
 170 typedef gfx::CoordTyped<DesktopPixel> DesktopCoord;
 171 typedef gfx::IntCoordTyped<DesktopPixel> DesktopIntCoord;
 172 typedef gfx::PointTyped<DesktopPixel> DesktopPoint;
 173 typedef gfx::IntPointTyped<DesktopPixel> DesktopIntPoint;
 174 typedef gfx::SizeTyped<DesktopPixel> DesktopSize;
 175 typedef gfx::IntSizeTyped<DesktopPixel> DesktopIntSize;
 176 typedef gfx::RectTyped<DesktopPixel> DesktopRect;
 177 typedef gfx::IntRectTyped<DesktopPixel> DesktopIntRect;
 178
 179 typedef gfx::CoordTyped<ExternalPixel> ExternalCoord;
 180 typedef gfx::IntCoordTyped<ExternalPixel> ExternalIntCoord;
 181 typedef gfx::PointTyped<ExternalPixel> ExternalPoint;
 182 typedef gfx::IntPointTyped<ExternalPixel> ExternalIntPoint;
 183 typedef gfx::SizeTyped<ExternalPixel> ExternalSize;
 184 typedef gfx::IntSizeTyped<ExternalPixel> ExternalIntSize;
 185 typedef gfx::RectTyped<ExternalPixel> ExternalRect;
 186 typedef gfx::IntRectTyped<ExternalPixel> ExternalIntRect;
 187 typedef gfx::MarginTyped<ExternalPixel> ExternalMargin;
 188 typedef gfx::IntMarginTyped<ExternalPixel> ExternalIntMargin;
 189 typedef gfx::IntRegionTyped<ExternalPixel> ExternalIntRegion;
 190
 191 typedef gfx::ScaleFactor<CSSPixel, CSSPixel> CSSToCSSScale;
 192 typedef gfx::ScaleFactor<CSSPixel, OuterCSSPixel> CSSToOuterCSSScale;
 193 typedef gfx::ScaleFactor<CSSPixel, LayoutDevicePixel> CSSToLayoutDeviceScale;
 194 typedef gfx::ScaleFactor<CSSPixel, LayerPixel> CSSToLayerScale;
 195 typedef gfx::ScaleFactor<CSSPixel, ScreenPixel> CSSToScreenScale;
 196 typedef gfx::ScaleFactor<CSSPixel, ParentLayerPixel> CSSToParentLayerScale;
 197 typedef gfx::ScaleFactor<CSSPixel, DesktopPixel> CSSToDesktopScale;
 198 typedef gfx::ScaleFactor<OuterCSSPixel, LayoutDevicePixel>
 199     OuterCSSToLayoutDeviceScale;
 200 typedef gfx::ScaleFactor<LayoutDevicePixel, CSSPixel> LayoutDeviceToCSSScale;
 201 typedef gfx::ScaleFactor<LayoutDevicePixel, LayerPixel>
 202     LayoutDeviceToLayerScale;
 203 typedef gfx::ScaleFactor<LayoutDevicePixel, ScreenPixel>
 204     LayoutDeviceToScreenScale;
 205 typedef gfx::ScaleFactor<LayoutDevicePixel, ParentLayerPixel>
 206     LayoutDeviceToParentLayerScale;
 207 typedef gfx::ScaleFactor<LayerPixel, CSSPixel> LayerToCSSScale;
 208 typedef gfx::ScaleFactor<LayerPixel, LayoutDevicePixel>
 209     LayerToLayoutDeviceScale;
 210 typedef gfx::ScaleFactor<LayerPixel, RenderTargetPixel>
 211     LayerToRenderTargetScale;
 212 typedef gfx::ScaleFactor<LayerPixel, ScreenPixel> LayerToScreenScale;
 213 typedef gfx::ScaleFactor<LayerPixel, ParentLayerPixel> LayerToParentLayerScale;
 214 typedef gfx::ScaleFactor<RenderTargetPixel, ScreenPixel>
 215     RenderTargetToScreenScale;
 216 typedef gfx::ScaleFactor<ScreenPixel, CSSPixel> ScreenToCSSScale;
 217 typedef gfx::ScaleFactor<ScreenPixel, LayoutDevicePixel>
 218     ScreenToLayoutDeviceScale;
 219 typedef gfx::ScaleFactor<ScreenPixel, LayerPixel> ScreenToLayerScale;
 220 typedef gfx::ScaleFactor<ScreenPixel, ParentLayerPixel>
 221     ScreenToParentLayerScale;
 222 typedef gfx::ScaleFactor<ParentLayerPixel, LayerPixel> ParentLayerToLayerScale;
 223 typedef gfx::ScaleFactor<ParentLayerPixel, ScreenPixel>
 224     ParentLayerToScreenScale;
 225 typedef gfx::ScaleFactor<ParentLayerPixel, ParentLayerPixel>
 226     ParentLayerToParentLayerScale;
 227 typedef gfx::ScaleFactor<DesktopPixel, LayoutDevicePixel>
 228     DesktopToLayoutDeviceScale;
 229 typedef gfx::ScaleFactor<LayoutDevicePixel, DesktopPixel>
 230     LayoutDeviceToDesktopScale;
 231
 232 typedef gfx::ScaleFactors2D<CSSPixel, LayoutDevicePixel>
 233     CSSToLayoutDeviceScale2D;
 234 typedef gfx::ScaleFactors2D<CSSPixel, LayerPixel> CSSToLayerScale2D;
 235 typedef gfx::ScaleFactors2D<CSSPixel, ScreenPixel> CSSToScreenScale2D;
 236 typedef gfx::ScaleFactors2D<CSSPixel, ParentLayerPixel> CSSToParentLayerScale2D;
 237 typedef gfx::ScaleFactors2D<LayoutDevicePixel, CSSPixel>
 238     LayoutDeviceToCSSScale2D;
 239 typedef gfx::ScaleFactors2D<LayoutDevicePixel, LayerPixel>
 240     LayoutDeviceToLayerScale2D;
 241 typedef gfx::ScaleFactors2D<LayoutDevicePixel, ScreenPixel>
 242     LayoutDeviceToScreenScale2D;
 243 typedef gfx::ScaleFactors2D<LayoutDevicePixel, ParentLayerPixel>
 244     LayoutDeviceToParentLayerScale2D;
 245 typedef gfx::ScaleFactors2D<LayerPixel, CSSPixel> LayerToCSSScale2D;
 246 typedef gfx::ScaleFactors2D<LayerPixel, LayoutDevicePixel>
 247     LayerToLayoutDeviceScale2D;
 248 typedef gfx::ScaleFactors2D<LayerPixel, RenderTargetPixel>
 249     LayerToRenderTargetScale2D;
 250 typedef gfx::ScaleFactors2D<LayerPixel, ScreenPixel> LayerToScreenScale2D;
 251 typedef gfx::ScaleFactors2D<LayerPixel, ParentLayerPixel>
 252     LayerToParentLayerScale2D;
 253 typedef gfx::ScaleFactors2D<RenderTargetPixel, ScreenPixel>
 254     RenderTargetToScreenScale2D;
 255 typedef gfx::ScaleFactors2D<ScreenPixel, CSSPixel> ScreenToCSSScale2D;
 256 typedef gfx::ScaleFactors2D<ScreenPixel, LayoutDevicePixel>
 257     ScreenToLayoutDeviceScale2D;
 258 typedef gfx::ScaleFactors2D<ScreenPixel, ScreenPixel> ScreenToScreenScale2D;
 259 typedef gfx::ScaleFactors2D<ScreenPixel, LayerPixel> ScreenToLayerScale2D;
 260 typedef gfx::ScaleFactors2D<ScreenPixel, ParentLayerPixel>
 261     ScreenToParentLayerScale2D;
 262 typedef gfx::ScaleFactors2D<ParentLayerPixel, LayerPixel>
 263     ParentLayerToLayerScale2D;
 264 typedef gfx::ScaleFactors2D<ParentLayerPixel, ScreenPixel>
 265     ParentLayerToScreenScale2D;
 266 typedef gfx::ScaleFactors2D<ParentLayerPixel, ParentLayerPixel>
 267     ParentLayerToParentLayerScale2D;
 268 typedef gfx::ScaleFactors2D<gfx::UnknownUnits, gfx::UnknownUnits> Scale2D;
 269
 270 typedef gfx::Matrix4x4Typed<CSSPixel, CSSPixel> CSSToCSSMatrix4x4;
 271 typedef gfx::Matrix4x4Typed<LayoutDevicePixel, LayoutDevicePixel>
 272     LayoutDeviceToLayoutDeviceMatrix4x4;
 273 typedef gfx::Matrix4x4Typed<LayoutDevicePixel, ParentLayerPixel>
 274     LayoutDeviceToParentLayerMatrix4x4;
 275 typedef gfx::Matrix4x4Typed<LayerPixel, ParentLayerPixel>
 276     LayerToParentLayerMatrix4x4;
 277 typedef gfx::Matrix4x4Typed<LayerPixel, ScreenPixel> LayerToScreenMatrix4x4;
 278 typedef gfx::Matrix4x4Typed<ScreenPixel, ScreenPixel> ScreenToScreenMatrix4x4;
 279 typedef gfx::Matrix4x4Typed<ScreenPixel, ParentLayerPixel>
 280     ScreenToParentLayerMatrix4x4;
 281 typedef gfx::Matrix4x4Typed<ParentLayerPixel, LayerPixel>
 282     ParentLayerToLayerMatrix4x4;
 283 typedef gfx::Matrix4x4Typed<ParentLayerPixel, ScreenPixel>
 284     ParentLayerToScreenMatrix4x4;
 285 typedef gfx::Matrix4x4Typed<ParentLayerPixel, ParentLayerPixel>
 286     ParentLayerToParentLayerMatrix4x4;
 287 typedef gfx::Matrix4x4Typed<ParentLayerPixel, RenderTargetPixel>
 288     ParentLayerToRenderTargetMatrix4x4;
 289 typedef gfx::Matrix4x4Typed<ExternalPixel, ParentLayerPixel>
 290     ExternalToParentLayerMatrix4x4;
 291
 292 /*
 293  * The pixels that content authors use to specify sizes in.
 294  */
 295 struct CSSPixel {
 296   // Conversions from app units
 297   static CSSCoord FromAppUnits(nscoord aCoord) {
 298     return NSAppUnitsToFloatPixels(aCoord, float(AppUnitsPerCSSPixel()));
 299   }
 300
 301   static CSSIntCoord FromAppUnitsRounded(nscoord aCoord) {
 302     return NSAppUnitsToIntPixels(aCoord, float(AppUnitsPerCSSPixel()));
 303   }
 304
 305   static CSSPoint FromAppUnits(const nsPoint& aPoint) {
 306     return CSSPoint(FromAppUnits(aPoint.x), FromAppUnits(aPoint.y));
 307   }
 308
 309   static CSSSize FromAppUnits(const nsSize& aSize) {
 310     return CSSSize(FromAppUnits(aSize.width), FromAppUnits(aSize.height));
 311   }
 312
 313   static CSSRect FromAppUnits(const nsRect& aRect) {
 314     return CSSRect(FromAppUnits(aRect.x), FromAppUnits(aRect.y),
 315                    FromAppUnits(aRect.Width()), FromAppUnits(aRect.Height()));
 316   }
 317
 318   static CSSMargin FromAppUnits(const nsMargin& aMargin) {
 319     return CSSMargin(FromAppUnits(aMargin.top), FromAppUnits(aMargin.right),
 320                      FromAppUnits(aMargin.bottom), FromAppUnits(aMargin.left));
 321   }
 322
 323   static CSSIntPoint FromAppUnitsRounded(const nsPoint& aPoint) {
 324     return CSSIntPoint(FromAppUnitsRounded(aPoint.x),
 325                        FromAppUnitsRounded(aPoint.y));
 326   }
 327
 328   static CSSIntSize FromAppUnitsRounded(const nsSize& aSize) {
 329     return CSSIntSize(FromAppUnitsRounded(aSize.width),
 330                       FromAppUnitsRounded(aSize.height));
 331   }
 332
 333   static CSSIntRect FromAppUnitsRounded(const nsRect& aRect) {
 334     return CSSIntRect(FromAppUnitsRounded(aRect.x),
 335                       FromAppUnitsRounded(aRect.y),
 336                       FromAppUnitsRounded(aRect.Width()),
 337                       FromAppUnitsRounded(aRect.Height()));
 338   }
 339
 340   static CSSIntMargin FromAppUnitsRounded(const nsMargin& aMargin) {
 341     return CSSIntMargin(
 342         FromAppUnitsRounded(aMargin.top), FromAppUnitsRounded(aMargin.right),
 343         FromAppUnitsRounded(aMargin.bottom), FromAppUnitsRounded(aMargin.left));
 344   }
 345
 346   static CSSIntRect FromAppUnitsToNearest(const nsRect& aRect) {
 347     return CSSIntRect::FromUnknownRect(
 348         aRect.ToNearestPixels(AppUnitsPerCSSPixel()));
 349   }
 350
 351   static CSSIntRect FromAppUnitsToInside(const nsRect& aRect) {
 352     return CSSIntRect::FromUnknownRect(
 353         aRect.ToInsidePixels(AppUnitsPerCSSPixel()));
 354   }
 355
 356   // Conversions to app units
 357
 358   // TODO: We might want an int32_t/CSSIntCoord overload which doesn't do float
 359   // math but we'd need to ensure stuff is clamped to nscoord_MIN/MAX range.
 360   static nscoord ToAppUnits(CSSCoord aCoord) {
 361     return NSFloatPixelsToAppUnits(aCoord, AppUnitsPerCSSPixel());
 362   }
 363
 364   static nsPoint ToAppUnits(const CSSPoint& aPoint) {
 365     return nsPoint(ToAppUnits(aPoint.x), ToAppUnits(aPoint.y));
 366   }
 367
 368   static nsPoint ToAppUnits(const CSSIntPoint& aPoint) {
 369     return nsPoint(ToAppUnits(CSSCoord(aPoint.x)),
 370                    ToAppUnits(CSSCoord(aPoint.y)));
 371   }
 372
 373   static nsSize ToAppUnits(const CSSSize& aSize) {
 374     return nsSize(ToAppUnits(aSize.width), ToAppUnits(aSize.height));
 375   }
 376
 377   static nsSize ToAppUnits(const CSSIntSize& aSize) {
 378     return nsSize(ToAppUnits(aSize.width), ToAppUnits(aSize.height));
 379   }
 380
 381   static nsRect ToAppUnits(const CSSRect& aRect) {
 382     return nsRect(ToAppUnits(aRect.x), ToAppUnits(aRect.y),
 383                   ToAppUnits(aRect.Width()), ToAppUnits(aRect.Height()));
 384   }
 385
 386   static nsRect ToAppUnits(const CSSIntRect& aRect) {
 387     return nsRect(ToAppUnits(aRect.x), ToAppUnits(aRect.y),
 388                   ToAppUnits(aRect.Width()), ToAppUnits(aRect.Height()));
 389   }
 390
 391   static nsMargin ToAppUnits(const CSSMargin& aMargin) {
 392     return nsMargin(ToAppUnits(aMargin.top), ToAppUnits(aMargin.right),
 393                     ToAppUnits(aMargin.bottom), ToAppUnits(aMargin.left));
 394   }
 395
 396   static nsMargin ToAppUnits(const CSSIntMargin& aMargin) {
 397     return nsMargin(ToAppUnits(CSSCoord(aMargin.top)),
 398                     ToAppUnits(CSSCoord(aMargin.right)),
 399                     ToAppUnits(CSSCoord(aMargin.bottom)),
 400                     ToAppUnits(CSSCoord(aMargin.left)));
 401   }
 402
 403   // Conversion from a given CSS point value.
 404   static CSSCoord FromPoints(float aCoord) {
 405     // One inch / 72.
 406     return aCoord * 96.0f / 72.0f;
 407   }
 408 };
 409
 410 /*
 411  * In the context of a scroll frame that is zoomable, OuterCSSPixel is
 412  * used to disambiguate CSS pixels of the content outside of the scroll
 413  * frame (which is not subject to the zoom) from CSS pixels of the content
 414  * inside the scroll frame (which is, and for which CSSPixel is used).
 415  */
 416 struct OuterCSSPixel {
 417   static OuterCSSCoord FromAppUnits(nscoord aCoord) {
 418     return NSAppUnitsToFloatPixels(aCoord, float(AppUnitsPerCSSPixel()));
 419   }
 420 };
 421
 422 /*
 423  * The pixels that are referred to as "device pixels" in layout code. In
 424  * general values measured in LayoutDevicePixels are obtained by dividing a
 425  * value in app units by AppUnitsPerDevPixel(). Conversion between CSS pixels
 426  * and LayoutDevicePixels is affected by:
 427  * 1) the "full zoom" (see nsPresContext::SetFullZoom)
 428  * 2) the "widget scale" (see nsIWidget::GetDefaultScale)
 429  */
 430 struct LayoutDevicePixel {
 431   static LayoutDeviceCoord FromAppUnits(nscoord aCoord,
 432                                         nscoord aAppUnitsPerDevPixel) {
 433     return LayoutDeviceCoord(
 434         NSAppUnitsToFloatPixels(aCoord, float(aAppUnitsPerDevPixel)));
 435   }
 436
 437   static LayoutDeviceIntCoord FromAppUnitsRounded(
 438       nscoord aCoord, nscoord aAppUnitsPerDevPixel) {
 439     return LayoutDeviceIntCoord(
 440         NSAppUnitsToIntPixels(aCoord, float(aAppUnitsPerDevPixel)));
 441   }
 442
 443   static LayoutDeviceRect FromAppUnits(const nsRect& aRect,
 444                                        nscoord aAppUnitsPerDevPixel) {
 445     return LayoutDeviceRect(FromAppUnits(aRect.x, aAppUnitsPerDevPixel),
 446                             FromAppUnits(aRect.y, aAppUnitsPerDevPixel),
 447                             FromAppUnits(aRect.Width(), aAppUnitsPerDevPixel),
 448                             FromAppUnits(aRect.Height(), aAppUnitsPerDevPixel));
 449   }
 450
 451   static LayoutDeviceSize FromAppUnits(const nsSize& aSize,
 452                                        nscoord aAppUnitsPerDevPixel) {
 453     return LayoutDeviceSize(FromAppUnits(aSize.width, aAppUnitsPerDevPixel),
 454                             FromAppUnits(aSize.height, aAppUnitsPerDevPixel));
 455   }
 456
 457   static LayoutDevicePoint FromAppUnits(const nsPoint& aPoint,
 458                                         nscoord aAppUnitsPerDevPixel) {
 459     return LayoutDevicePoint(FromAppUnits(aPoint.x, aAppUnitsPerDevPixel),
 460                              FromAppUnits(aPoint.y, aAppUnitsPerDevPixel));
 461   }
 462
 463   static LayoutDeviceMargin FromAppUnits(const nsMargin& aMargin,
 464                                          nscoord aAppUnitsPerDevPixel) {
 465     return LayoutDeviceMargin(
 466         FromAppUnits(aMargin.top, aAppUnitsPerDevPixel),
 467         FromAppUnits(aMargin.right, aAppUnitsPerDevPixel),
 468         FromAppUnits(aMargin.bottom, aAppUnitsPerDevPixel),
 469         FromAppUnits(aMargin.left, aAppUnitsPerDevPixel));
 470   }
 471
 472   static LayoutDeviceIntPoint FromAppUnitsRounded(
 473       const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
 474     return LayoutDeviceIntPoint(
 475         FromAppUnitsRounded(aPoint.x, aAppUnitsPerDevPixel),
 476         FromAppUnitsRounded(aPoint.y, aAppUnitsPerDevPixel));
 477   }
 478
 479   static LayoutDeviceIntRect FromAppUnitsRounded(const nsRect& aRect,
 480                                                  nscoord aAppUnitsPerDevPixel) {
 481     return LayoutDeviceIntRect(
 482         FromAppUnitsRounded(aRect.x, aAppUnitsPerDevPixel),
 483         FromAppUnitsRounded(aRect.y, aAppUnitsPerDevPixel),
 484         FromAppUnitsRounded(aRect.Width(), aAppUnitsPerDevPixel),
 485         FromAppUnitsRounded(aRect.Height(), aAppUnitsPerDevPixel));
 486   }
 487
 488   static LayoutDeviceIntPoint FromAppUnitsToNearest(
 489       const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) {
 490     return LayoutDeviceIntPoint::FromUnknownPoint(
 491         aPoint.ToNearestPixels(aAppUnitsPerDevPixel));
 492   }
 493
 494   static LayoutDeviceIntRect FromAppUnitsToNearest(
 495       const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
 496     return LayoutDeviceIntRect::FromUnknownRect(
 497         aRect.ToNearestPixels(aAppUnitsPerDevPixel));
 498   }
 499
 500   static LayoutDeviceIntRect FromAppUnitsToInside(
 501       const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
 502     return LayoutDeviceIntRect::FromUnknownRect(
 503         aRect.ToInsidePixels(aAppUnitsPerDevPixel));
 504   }
 505
 506   static LayoutDeviceIntRect FromAppUnitsToOutside(
 507       const nsRect& aRect, nscoord aAppUnitsPerDevPixel) {
 508     return LayoutDeviceIntRect::FromUnknownRect(
 509         aRect.ToOutsidePixels(aAppUnitsPerDevPixel));
 510   }
 511
 512   static LayoutDeviceIntSize FromAppUnitsRounded(const nsSize& aSize,
 513                                                  nscoord aAppUnitsPerDevPixel) {
 514     return LayoutDeviceIntSize(
 515         FromAppUnitsRounded(aSize.width, aAppUnitsPerDevPixel),
 516         FromAppUnitsRounded(aSize.height, aAppUnitsPerDevPixel));
 517   }
 518
 519   static LayoutDeviceIntMargin FromAppUnitsRounded(
 520       const nsMargin& aMargin, nscoord aAppUnitsPerDevPixel) {
 521     return LayoutDeviceIntMargin(
 522         FromAppUnitsRounded(aMargin.top, aAppUnitsPerDevPixel),
 523         FromAppUnitsRounded(aMargin.right, aAppUnitsPerDevPixel),
 524         FromAppUnitsRounded(aMargin.bottom, aAppUnitsPerDevPixel),
 525         FromAppUnitsRounded(aMargin.left, aAppUnitsPerDevPixel));
 526   }
 527
 528   static nscoord ToAppUnits(LayoutDeviceIntCoord aCoord,
 529                             nscoord aAppUnitsPerDevPixel) {
 530     return aCoord * aAppUnitsPerDevPixel;
 531   }
 532
 533   static nscoord ToAppUnits(int32_t aCoord, nscoord aAppUnitsPerDevPixel) {
 534     return ToAppUnits(LayoutDeviceIntCoord(aCoord), aAppUnitsPerDevPixel);
 535   }
 536
 537   static nscoord ToAppUnits(LayoutDeviceCoord aCoord,
 538                             nscoord aAppUnitsPerDevPixel) {
 539     return NSFloatPixelsToAppUnits(aCoord, aAppUnitsPerDevPixel);
 540   }
 541
 542   static nscoord ToAppUnits(float aCoord, nscoord aAppUnitsPerDevPixel) {
 543     return ToAppUnits(LayoutDeviceCoord(aCoord), aAppUnitsPerDevPixel);
 544   }
 545
 546   static nsPoint ToAppUnits(const LayoutDeviceIntPoint& aPoint,
 547                             nscoord aAppUnitsPerDevPixel) {
 548     return nsPoint(ToAppUnits(aPoint.x, aAppUnitsPerDevPixel),
 549                    ToAppUnits(aPoint.y, aAppUnitsPerDevPixel));
 550   }
 551
 552   static nsSize ToAppUnits(const LayoutDeviceIntSize& aSize,
 553                            nscoord aAppUnitsPerDevPixel) {
 554     return nsSize(ToAppUnits(aSize.width, aAppUnitsPerDevPixel),
 555                   ToAppUnits(aSize.height, aAppUnitsPerDevPixel));
 556   }
 557
 558   static nsSize ToAppUnits(const LayoutDeviceSize& aSize,
 559                            nscoord aAppUnitsPerDevPixel) {
 560     return nsSize(ToAppUnits(aSize.width, aAppUnitsPerDevPixel),
 561                   ToAppUnits(aSize.height, aAppUnitsPerDevPixel));
 562   }
 563
 564   static nsRect ToAppUnits(const LayoutDeviceIntRect& aRect,
 565                            nscoord aAppUnitsPerDevPixel) {
 566     return nsRect(ToAppUnits(aRect.x, aAppUnitsPerDevPixel),
 567                   ToAppUnits(aRect.y, aAppUnitsPerDevPixel),
 568                   ToAppUnits(aRect.Width(), aAppUnitsPerDevPixel),
 569                   ToAppUnits(aRect.Height(), aAppUnitsPerDevPixel));
 570   }
 571
 572   static nsRect ToAppUnits(const LayoutDeviceRect& aRect,
 573                            nscoord aAppUnitsPerDevPixel) {
 574     return nsRect(ToAppUnits(aRect.x, aAppUnitsPerDevPixel),
 575                   ToAppUnits(aRect.y, aAppUnitsPerDevPixel),
 576                   ToAppUnits(aRect.Width(), aAppUnitsPerDevPixel),
 577                   ToAppUnits(aRect.Height(), aAppUnitsPerDevPixel));
 578   }
 579
 580   static nsMargin ToAppUnits(const LayoutDeviceIntMargin& aMargin,
 581                              nscoord aAppUnitsPerDevPixel) {
 582     return nsMargin(ToAppUnits(aMargin.top, aAppUnitsPerDevPixel),
 583                     ToAppUnits(aMargin.right, aAppUnitsPerDevPixel),
 584                     ToAppUnits(aMargin.bottom, aAppUnitsPerDevPixel),
 585                     ToAppUnits(aMargin.left, aAppUnitsPerDevPixel));
 586   }
 587
 588   static nsMargin ToAppUnits(const LayoutDeviceMargin& aMargin,
 589                              nscoord aAppUnitsPerDevPixel) {
 590     return nsMargin(ToAppUnits(aMargin.top, aAppUnitsPerDevPixel),
 591                     ToAppUnits(aMargin.right, aAppUnitsPerDevPixel),
 592                     ToAppUnits(aMargin.bottom, aAppUnitsPerDevPixel),
 593                     ToAppUnits(aMargin.left, aAppUnitsPerDevPixel));
 594   }
 595 };
 596
 597 /*
 598  * The pixels that layout rasterizes and delivers to the graphics code.
 599  * These also are generally referred to as "device pixels" in layout code.
 600  * Conversion between CSS pixels and LayerPixels is affected by:
 601  * 1) the "display resolution" (see PresShell::SetResolution)
 602  * 2) the "full zoom" (see nsPresContext::SetFullZoom)
 603  * 3) the "widget scale" (see nsIWidget::GetDefaultScale)
 604  * 4) rasterizing at a different scale in the presence of some CSS transforms
 605  */
 606 struct LayerPixel {};
 607
 608 /*
 609  * This is Layer coordinates with the Layer's CSS transform applied.
 610  * It can be thought of as intermediate between LayerPixel and
 611  * ParentLayerPixel, as further applying async transforms to this
 612  * yields ParentLayerPixels.
 613  */
 614 struct CSSTransformedLayerPixel {};
 615
 616 /*
 617  * Layers are always composited to a render target. This unit
 618  * represents one pixel in the render target. Note that for the
 619  * root render target RenderTargetPixel == ScreenPixel. Also
 620  * any ContainerLayer providing an intermediate surface will
 621  * have RenderTargetPixel == LayerPixel.
 622  */
 623 struct RenderTargetPixel {};
 624
 625 /*
 626  * This unit represents one pixel in an image. Image space
 627  * is largely independent of any other space.
 628  */
 629 struct ImagePixel {};
 630
 631 /*
 632  * The pixels that are displayed on the screen.
 633  * On non-OMTC platforms this should be equivalent to LayerPixel units.
 634  * On OMTC platforms these may diverge from LayerPixel units temporarily,
 635  * while an asynchronous zoom is happening, but should eventually converge
 636  * back to LayerPixel units. Some variables (such as those representing
 637  * chrome UI element sizes) that are not subject to content zoom should
 638  * generally be represented in ScreenPixel units.
 639  */
 640 struct ScreenPixel {};
 641
 642 /* The layer coordinates of the parent frame.
 643  * This can be arrived at in three ways:
 644  *   - Start with the CSS coordinates of the parent frame, multiply by the
 645  *     device scale and the cumulative resolution of the parent frame.
 646  *   - Start with the CSS coordinates of current frame, multiply by the device
 647  *     scale, the cumulative resolution of the current frame, and the scales
 648  *     from the CSS and async transforms of the current frame.
 649  *   - Start with global screen coordinates and unapply all CSS and async
 650  *     transforms from the root down to and including the parent.
 651  * It's helpful to look at
 652  * https://wiki.mozilla.org/Platform/GFX/APZ#Coordinate_systems to get a picture
 653  * of how the various coordinate systems relate to each other.
 654  */
 655 struct ParentLayerPixel {};
 656
 657 /*
 658  * Pixels in the coordinate space used by the host OS to manage windows on the
 659  * desktop. What these mean varies between OSs:
 660  * - by default (unless implemented differently in platform-specific widget
 661  *   code) they are the same as LayoutDevicePixels
 662  * - on Mac OS X, they're "cocoa points", which correspond to device pixels
 663  *   on a non-Retina display, and to 2x device pixels on Retina
 664  * - on Windows *without* per-monitor DPI support, they are Windows "logical
 665  *   pixels", i.e. device pixels scaled according to the Windows display DPI
 666  *   scaling factor (typically one of 1.25, 1.5, 1.75, 2.0...)
 667  * - on Windows *with* per-monitor DPI support, they are physical device pixels
 668  *   on each screen; note that this means the scaling between CSS pixels and
 669  *   desktop pixels may vary across multiple displays.
 670  */
 671 struct DesktopPixel {};
 672
 673 struct ExternalPixel {};
 674
 675 // Operators to apply ScaleFactors directly to Coords, Points, Rects, Sizes and
 676 // Margins
 677
 678 template <class Src, class Dst>
 679 gfx::CoordTyped<Dst> operator*(const gfx::CoordTyped<Src>& aCoord,
 680                                const gfx::ScaleFactor<Src, Dst>& aScale) {
 681   return gfx::CoordTyped<Dst>(aCoord.value * aScale.scale);
 682 }
 683
 684 template <class Src, class Dst>
 685 gfx::CoordTyped<Dst> operator/(const gfx::CoordTyped<Src>& aCoord,
 686                                const gfx::ScaleFactor<Dst, Src>& aScale) {
 687   return gfx::CoordTyped<Dst>(aCoord.value / aScale.scale);
 688 }
 689
 690 template <class Src, class Dst>
 691 gfx::PointTyped<Dst> operator*(const gfx::PointTyped<Src>& aPoint,
 692                                const gfx::ScaleFactor<Src, Dst>& aScale) {
 693   return gfx::PointTyped<Dst>(aPoint.x * aScale.scale, aPoint.y * aScale.scale);
 694 }
 695
 696 template <class Src, class Dst>
 697 gfx::PointTyped<Dst> operator/(const gfx::PointTyped<Src>& aPoint,
 698                                const gfx::ScaleFactor<Dst, Src>& aScale) {
 699   return gfx::PointTyped<Dst>(aPoint.x / aScale.scale, aPoint.y / aScale.scale);
 700 }
 701
 702 template <class Src, class Dst, class F>
 703 gfx::PointTyped<Dst, F> operator*(
 704     const gfx::PointTyped<Src, F>& aPoint,
 705     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 706   return gfx::PointTyped<Dst, F>(aPoint.x * aScale.xScale,
 707                                  aPoint.y * aScale.yScale);
 708 }
 709
 710 template <class Src, class Dst, class F>
 711 gfx::PointTyped<Dst, F> operator/(
 712     const gfx::PointTyped<Src, F>& aPoint,
 713     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 714   return gfx::PointTyped<Dst, F>(aPoint.x / aScale.xScale,
 715                                  aPoint.y / aScale.yScale);
 716 }
 717
 718 template <class Src, class Dst>
 719 gfx::PointTyped<Dst> operator*(const gfx::IntPointTyped<Src>& aPoint,
 720                                const gfx::ScaleFactor<Src, Dst>& aScale) {
 721   return gfx::PointTyped<Dst>(float(aPoint.x) * aScale.scale,
 722                               float(aPoint.y) * aScale.scale);
 723 }
 724
 725 template <class Src, class Dst>
 726 gfx::PointTyped<Dst> operator/(const gfx::IntPointTyped<Src>& aPoint,
 727                                const gfx::ScaleFactor<Dst, Src>& aScale) {
 728   return gfx::PointTyped<Dst>(float(aPoint.x) / aScale.scale,
 729                               float(aPoint.y) / aScale.scale);
 730 }
 731
 732 template <class Src, class Dst, class F>
 733 gfx::PointTyped<Dst, F> operator*(
 734     const gfx::IntPointTyped<Src>& aPoint,
 735     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 736   return gfx::PointTyped<Dst, F>(F(aPoint.x) * aScale.xScale,
 737                                  F(aPoint.y) * aScale.yScale);
 738 }
 739
 740 template <class Src, class Dst, class F>
 741 gfx::PointTyped<Dst, F> operator/(
 742     const gfx::IntPointTyped<Src>& aPoint,
 743     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 744   return gfx::PointTyped<Dst, F>(F(aPoint.x) / aScale.xScale,
 745                                  F(aPoint.y) / aScale.yScale);
 746 }
 747
 748 template <class Src, class Dst>
 749 gfx::RectTyped<Dst> operator*(const gfx::RectTyped<Src>& aRect,
 750                               const gfx::ScaleFactor<Src, Dst>& aScale) {
 751   return gfx::RectTyped<Dst>(aRect.x * aScale.scale, aRect.y * aScale.scale,
 752                              aRect.Width() * aScale.scale,
 753                              aRect.Height() * aScale.scale);
 754 }
 755
 756 template <class Src, class Dst>
 757 gfx::RectTyped<Dst> operator/(const gfx::RectTyped<Src>& aRect,
 758                               const gfx::ScaleFactor<Dst, Src>& aScale) {
 759   return gfx::RectTyped<Dst>(aRect.x / aScale.scale, aRect.y / aScale.scale,
 760                              aRect.Width() / aScale.scale,
 761                              aRect.Height() / aScale.scale);
 762 }
 763
 764 template <class Src, class Dst, class F>
 765 gfx::RectTyped<Dst, F> operator*(
 766     const gfx::RectTyped<Src, F>& aRect,
 767     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 768   return gfx::RectTyped<Dst, F>(
 769       aRect.x * aScale.xScale, aRect.y * aScale.yScale,
 770       aRect.Width() * aScale.xScale, aRect.Height() * aScale.yScale);
 771 }
 772
 773 template <class Src, class Dst, class F>
 774 gfx::RectTyped<Dst, F> operator/(
 775     const gfx::RectTyped<Src, F>& aRect,
 776     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 777   return gfx::RectTyped<Dst, F>(
 778       aRect.x / aScale.xScale, aRect.y / aScale.yScale,
 779       aRect.Width() / aScale.xScale, aRect.Height() / aScale.yScale);
 780 }
 781
 782 template <class Src, class Dst>
 783 gfx::RectTyped<Dst> operator*(const gfx::IntRectTyped<Src>& aRect,
 784                               const gfx::ScaleFactor<Src, Dst>& aScale) {
 785   return gfx::RectTyped<Dst>(float(aRect.x) * aScale.scale,
 786                              float(aRect.y) * aScale.scale,
 787                              float(aRect.Width()) * aScale.scale,
 788                              float(aRect.Height()) * aScale.scale);
 789 }
 790
 791 template <class Src, class Dst>
 792 gfx::RectTyped<Dst> operator/(const gfx::IntRectTyped<Src>& aRect,
 793                               const gfx::ScaleFactor<Dst, Src>& aScale) {
 794   return gfx::RectTyped<Dst>(float(aRect.x) / aScale.scale,
 795                              float(aRect.y) / aScale.scale,
 796                              float(aRect.Width()) / aScale.scale,
 797                              float(aRect.Height()) / aScale.scale);
 798 }
 799
 800 template <class Src, class Dst, class F>
 801 gfx::RectTyped<Dst, F> operator*(
 802     const gfx::IntRectTyped<Src>& aRect,
 803     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 804   return gfx::RectTyped<Dst, F>(
 805       F(aRect.x) * aScale.xScale, F(aRect.y) * aScale.yScale,
 806       F(aRect.Width()) * aScale.xScale, F(aRect.Height()) * aScale.yScale);
 807 }
 808
 809 template <class Src, class Dst, class F>
 810 gfx::RectTyped<Dst, F> operator/(
 811     const gfx::IntRectTyped<Src>& aRect,
 812     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 813   return gfx::RectTyped<Dst, F>(
 814       F(aRect.x) / aScale.xScale, F(aRect.y) / aScale.yScale,
 815       F(aRect.Width()) / aScale.xScale, F(aRect.Height()) / aScale.yScale);
 816 }
 817
 818 template <class Src, class Dst>
 819 gfx::SizeTyped<Dst> operator*(const gfx::SizeTyped<Src>& aSize,
 820                               const gfx::ScaleFactor<Src, Dst>& aScale) {
 821   return gfx::SizeTyped<Dst>(aSize.width * aScale.scale,
 822                              aSize.height * aScale.scale);
 823 }
 824
 825 template <class Src, class Dst>
 826 gfx::SizeTyped<Dst> operator/(const gfx::SizeTyped<Src>& aSize,
 827                               const gfx::ScaleFactor<Dst, Src>& aScale) {
 828   return gfx::SizeTyped<Dst>(aSize.width / aScale.scale,
 829                              aSize.height / aScale.scale);
 830 }
 831
 832 template <class Src, class Dst, class F>
 833 gfx::SizeTyped<Dst, F> operator*(
 834     const gfx::SizeTyped<Src, F>& aSize,
 835     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 836   return gfx::SizeTyped<Dst, F>(aSize.width * aScale.xScale,
 837                                 aSize.height * aScale.yScale);
 838 }
 839
 840 template <class Src, class Dst, class F>
 841 gfx::SizeTyped<Dst, F> operator/(
 842     const gfx::SizeTyped<Src, F>& aSize,
 843     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 844   return gfx::SizeTyped<Dst, F>(aSize.width / aScale.xScale,
 845                                 aSize.height / aScale.yScale);
 846 }
 847
 848 template <class Src, class Dst>
 849 gfx::SizeTyped<Dst> operator*(const gfx::IntSizeTyped<Src>& aSize,
 850                               const gfx::ScaleFactor<Src, Dst>& aScale) {
 851   return gfx::SizeTyped<Dst>(float(aSize.width) * aScale.scale,
 852                              float(aSize.height) * aScale.scale);
 853 }
 854
 855 template <class Src, class Dst>
 856 gfx::SizeTyped<Dst> operator/(const gfx::IntSizeTyped<Src>& aSize,
 857                               const gfx::ScaleFactor<Dst, Src>& aScale) {
 858   return gfx::SizeTyped<Dst>(float(aSize.width) / aScale.scale,
 859                              float(aSize.height) / aScale.scale);
 860 }
 861
 862 template <class Src, class Dst, class F>
 863 gfx::SizeTyped<Dst, F> operator*(
 864     const gfx::IntSizeTyped<Src>& aSize,
 865     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 866   return gfx::SizeTyped<Dst, F>(F(aSize.width) * aScale.xScale,
 867                                 F(aSize.height) * aScale.yScale);
 868 }
 869
 870 template <class Src, class Dst, class F>
 871 gfx::SizeTyped<Dst, F> operator/(
 872     const gfx::IntSizeTyped<Src>& aSize,
 873     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 874   return gfx::SizeTyped<Dst, F>(F(aSize.width) / aScale.xScale,
 875                                 F(aSize.height) / aScale.yScale);
 876 }
 877
 878 template <class Src, class Dst>
 879 gfx::MarginTyped<Dst> operator*(const gfx::MarginTyped<Src>& aMargin,
 880                                 const gfx::ScaleFactor<Src, Dst>& aScale) {
 881   return gfx::MarginTyped<Dst>(
 882       aMargin.top.value * aScale.scale, aMargin.right.value * aScale.scale,
 883       aMargin.bottom.value * aScale.scale, aMargin.left.value * aScale.scale);
 884 }
 885
 886 template <class Src, class Dst>
 887 gfx::MarginTyped<Dst> operator/(const gfx::MarginTyped<Src>& aMargin,
 888                                 const gfx::ScaleFactor<Dst, Src>& aScale) {
 889   return gfx::MarginTyped<Dst>(
 890       aMargin.top / aScale.scale, aMargin.right / aScale.scale,
 891       aMargin.bottom / aScale.scale, aMargin.left / aScale.scale);
 892 }
 893
 894 template <class Src, class Dst, class F>
 895 gfx::MarginTyped<Dst, F> operator*(
 896     const gfx::MarginTyped<Src, F>& aMargin,
 897     const gfx::BaseScaleFactors2D<Src, Dst, F>& aScale) {
 898   return gfx::MarginTyped<Dst, F>(
 899       aMargin.top.value * aScale.yScale, aMargin.right.value * aScale.xScale,
 900       aMargin.bottom.value * aScale.yScale, aMargin.left.value * aScale.xScale);
 901 }
 902
 903 template <class Src, class Dst, class F>
 904 gfx::MarginTyped<Dst, F> operator/(
 905     const gfx::MarginTyped<Src, F>& aMargin,
 906     const gfx::BaseScaleFactors2D<Dst, Src, F>& aScale) {
 907   return gfx::MarginTyped<Dst, F>(
 908       aMargin.top.value / aScale.yScale, aMargin.right.value / aScale.xScale,
 909       aMargin.bottom.value / aScale.yScale, aMargin.left.value / aScale.xScale);
 910 }
 911
 912 // Calculate the max or min or the ratios of the widths and heights of two
 913 // sizes, returning a scale factor in the correct units.
 914
 915 template <class Src, class Dst>
 916 gfx::ScaleFactor<Src, Dst> MaxScaleRatio(const gfx::SizeTyped<Dst>& aDestSize,
 917                                          const gfx::SizeTyped<Src>& aSrcSize) {
 918   MOZ_ASSERT(aSrcSize.width != 0 && aSrcSize.height != 0,
 919              "Caller must verify aSrcSize has nonzero components, "
 920              "to avoid division by 0 here");
 921   return gfx::ScaleFactor<Src, Dst>(std::max(
 922       aDestSize.width / aSrcSize.width, aDestSize.height / aSrcSize.height));
 923 }
 924
 925 template <class Src, class Dst>
 926 gfx::ScaleFactor<Src, Dst> MinScaleRatio(const gfx::SizeTyped<Dst>& aDestSize,
 927                                          const gfx::SizeTyped<Src>& aSrcSize) {
 928   MOZ_ASSERT(aSrcSize.width != 0 && aSrcSize.height != 0,
 929              "Caller must verify aSrcSize has nonzero components, "
 930              "to avoid division by 0 here");
 931   return gfx::ScaleFactor<Src, Dst>(std::min(
 932       aDestSize.width / aSrcSize.width, aDestSize.height / aSrcSize.height));
 933 }
 934
 935 template <typename T>
 936 struct CoordOfImpl;
 937
 938 template <typename Units>
 939 struct CoordOfImpl<gfx::PointTyped<Units>> {
 940   typedef gfx::CoordTyped<Units> Type;
 941 };
 942
 943 template <typename Units>
 944 struct CoordOfImpl<gfx::IntPointTyped<Units>> {
 945   typedef gfx::IntCoordTyped<Units> Type;
 946 };
 947
 948 template <typename Units>
 949 struct CoordOfImpl<gfx::RectTyped<Units>> {
 950   typedef gfx::CoordTyped<Units> Type;
 951 };
 952
 953 template <typename Units>
 954 struct CoordOfImpl<gfx::IntRectTyped<Units>> {
 955   typedef gfx::IntCoordTyped<Units> Type;
 956 };
 957
 958 template <typename Units>
 959 struct CoordOfImpl<gfx::SizeTyped<Units>> {
 960   typedef gfx::CoordTyped<Units> Type;
 961 };
 962
 963 template <typename T>
 964 using CoordOf = typename CoordOfImpl<T>::Type;
 965
 966 }  // namespace mozilla
 967
 968 #endif