Backed out changeset 38577c007450 (bug 1424371) for Marionett test failure on testing/marionette/harness/marionette_harness/tests/unit/test_window_maximize.py. CLOSED TREE
authorDorel Luca <dluca@mozilla.com>
Mon, 19 Feb 2018 22:15:23 +0200
changeset 456900 92d362925563bf9dfb056255d5d018a84c63bc44
parent 456899 a75f30d856c949c557b59607e411a1b37ea2b5f0
child 456901 51a44c186dddd2ae9a9f244372251dd8c5bf47be
push id8799
push usermtabara@mozilla.com
push dateThu, 01 Mar 2018 16:46:23 +0000
treeherdermozilla-beta@15334014dc67 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1424371
milestone60.0a1
backs out38577c007450d641cfe792a974787cde0bbe1410
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changeset 38577c007450 (bug 1424371) for Marionett test failure on testing/marionette/harness/marionette_harness/tests/unit/test_window_maximize.py. CLOSED TREE
dom/base/DOMIntersectionObserver.cpp
dom/base/DOMRect.cpp
dom/base/Element.h
dom/base/Selection.cpp
dom/base/nsDOMWindowUtils.cpp
dom/base/nsFocusManager.cpp
dom/base/nsFrameLoader.cpp
dom/base/nsGlobalWindowOuter.cpp
dom/base/nsQueryContentEventResult.cpp
dom/base/nsRange.cpp
dom/base/nsScreen.cpp
dom/base/nsScreen.h
dom/canvas/CanvasRenderingContext2D.cpp
dom/canvas/CanvasRenderingContext2D.h
dom/canvas/ImageBitmap.cpp
dom/events/ContentEventHandler.cpp
dom/events/EventStateManager.cpp
dom/events/WheelHandlingHelper.cpp
dom/html/HTMLCanvasElement.cpp
dom/html/ImageDocument.cpp
dom/html/MediaDocument.cpp
dom/html/nsGenericHTMLElement.h
dom/ipc/TabChild.cpp
dom/ipc/TabParent.cpp
dom/media/MediaData.cpp
dom/media/MediaInfo.h
dom/media/VideoUtils.cpp
dom/media/platforms/wmf/WMFVideoMFTManager.cpp
dom/media/webm/WebMDemuxer.cpp
dom/plugins/ipc/PluginInstanceChild.cpp
dom/plugins/ipc/PluginInstanceParent.cpp
dom/svg/SVGFEImageElement.cpp
dom/svg/SVGFETurbulenceElement.cpp
dom/svg/SVGImageElement.cpp
dom/svg/SVGRect.cpp
dom/svg/SVGRectElement.cpp
dom/xul/XULDocument.cpp
--- a/dom/base/DOMIntersectionObserver.cpp
+++ b/dom/base/DOMIntersectionObserver.cpp
@@ -250,18 +250,18 @@ CheckSimilarOrigin(nsINode* aNode1, nsIN
   }
 
   return baseDomain1 == baseDomain2;
 }
 
 static Maybe<nsRect>
 EdgeInclusiveIntersection(const nsRect& aRect, const nsRect& aOtherRect)
 {
-  nscoord left = std::max(aRect.X(), aOtherRect.X());
-  nscoord top = std::max(aRect.Y(), aOtherRect.Y());
+  nscoord left = std::max(aRect.x, aOtherRect.x);
+  nscoord top = std::max(aRect.y, aOtherRect.y);
   nscoord right = std::min(aRect.XMost(), aOtherRect.XMost());
   nscoord bottom = std::min(aRect.YMost(), aOtherRect.YMost());
   if (left > right || top > bottom) {
     return Nothing();
   }
   return Some(nsRect(left, top, right - left, bottom - top));
 }
 
--- a/dom/base/DOMRect.cpp
+++ b/dom/base/DOMRect.cpp
@@ -114,13 +114,13 @@ RoundFloat(double aValue)
 void
 DOMRect::SetLayoutRect(const nsRect& aLayoutRect)
 {
   double scale = 65536.0;
   // Round to the nearest 1/scale units. We choose scale so it can be represented
   // exactly by machine floating point.
   double scaleInv = 1/scale;
   double t2pScaled = scale/nsPresContext::AppUnitsPerCSSPixel();
-  double x = RoundFloat(aLayoutRect.X()*t2pScaled)*scaleInv;
-  double y = RoundFloat(aLayoutRect.Y()*t2pScaled)*scaleInv;
+  double x = RoundFloat(aLayoutRect.x*t2pScaled)*scaleInv;
+  double y = RoundFloat(aLayoutRect.y*t2pScaled)*scaleInv;
   SetRect(x, y, RoundFloat(aLayoutRect.XMost()*t2pScaled)*scaleInv - x,
           RoundFloat(aLayoutRect.YMost()*t2pScaled)*scaleInv - y);
 }
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -1341,48 +1341,48 @@ public:
   MOZ_CAN_RUN_SCRIPT void SetScrollTop(int32_t aScrollTop);
   MOZ_CAN_RUN_SCRIPT int32_t ScrollLeft();
   MOZ_CAN_RUN_SCRIPT void SetScrollLeft(int32_t aScrollLeft);
   MOZ_CAN_RUN_SCRIPT int32_t ScrollWidth();
   MOZ_CAN_RUN_SCRIPT int32_t ScrollHeight();
   MOZ_CAN_RUN_SCRIPT void MozScrollSnap();
   MOZ_CAN_RUN_SCRIPT int32_t ClientTop()
   {
-    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().Y());
+    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().y);
   }
   MOZ_CAN_RUN_SCRIPT int32_t ClientLeft()
   {
-    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().X());
+    return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().x);
   }
   MOZ_CAN_RUN_SCRIPT int32_t ClientWidth()
   {
     return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().Width());
   }
   MOZ_CAN_RUN_SCRIPT int32_t ClientHeight()
   {
     return nsPresContext::AppUnitsToIntCSSPixels(GetClientAreaRect().Height());
   }
   MOZ_CAN_RUN_SCRIPT int32_t ScrollTopMin()
   {
     nsIScrollableFrame* sf = GetScrollFrame();
     return sf ?
-           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().Y()) : 0;
+           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().y) : 0;
   }
   MOZ_CAN_RUN_SCRIPT int32_t ScrollTopMax()
   {
     nsIScrollableFrame* sf = GetScrollFrame();
     return sf ?
            nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().YMost()) :
            0;
   }
   MOZ_CAN_RUN_SCRIPT int32_t ScrollLeftMin()
   {
     nsIScrollableFrame* sf = GetScrollFrame();
     return sf ?
-           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().X()) : 0;
+           nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().x) : 0;
   }
   MOZ_CAN_RUN_SCRIPT int32_t ScrollLeftMax()
   {
     nsIScrollableFrame* sf = GetScrollFrame();
     return sf ?
            nsPresContext::AppUnitsToIntCSSPixels(sf->GetScrollRange().XMost()) :
            0;
   }
--- a/dom/base/Selection.cpp
+++ b/dom/base/Selection.cpp
@@ -2200,21 +2200,21 @@ Selection::DoAutoScroll(nsIFrame* aFrame
       // If aPoint is at the screen edge then try to scroll anyway, once.
       RefPtr<nsDeviceContext> dx = shell->GetViewManager()->GetDeviceContext();
       nsRect screen;
       dx->GetRect(screen);
       nsPoint screenPoint = globalPoint +
                             rootmostFrame->GetScreenRectInAppUnits().TopLeft();
       nscoord onePx = nsPresContext::AppUnitsPerCSSPixel();
       nscoord scrollAmount = 10 * onePx;
-      if (std::abs(screen.X() - screenPoint.x) <= onePx) {
+      if (std::abs(screen.x - screenPoint.x) <= onePx) {
         aPoint.x -= scrollAmount;
       } else if (std::abs(screen.XMost() - screenPoint.x) <= onePx) {
         aPoint.x += scrollAmount;
-      } else if (std::abs(screen.Y() - screenPoint.y) <= onePx) {
+      } else if (std::abs(screen.y - screenPoint.y) <= onePx) {
         aPoint.y -= scrollAmount;
       } else if (std::abs(screen.YMost() - screenPoint.y) <= onePx) {
         aPoint.y += scrollAmount;
       } else {
         break;
       }
       done = true;
       continue;
@@ -3516,20 +3516,20 @@ Selection::GetSelectionEndPointGeometry(
     // Get the x coordinate of the offset into the text frame.
     rv = GetCachedFrameOffset(frame, nodeOffset, pt);
     if (NS_FAILED(rv))
       return nullptr;
   }
 
   // Return the rect relative to the frame, with zero width.
   if (isText) {
-    aRect->MoveToX(pt.x);
+    aRect->x = pt.x;
   } else if (mFrameSelection->GetHint() == CARET_ASSOCIATE_BEFORE) {
     // It's the frame's right edge we're interested in.
-    aRect->MoveToX(frame->GetRect().Width());
+    aRect->x = frame->GetRect().Width();
   }
   aRect->SetHeight(frame->GetRect().Height());
 
   return frame;
 }
 
 NS_IMETHODIMP
 Selection::ScrollSelectionIntoViewEvent::Run()
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -1738,18 +1738,18 @@ nsDOMWindowUtils::GetRootBounds(nsIDOMCl
       bounds.SetHeight(bounds.Height() + sf->GetScrollPortRect().Height());
     } else if (presShell->GetRootFrame()) {
       bounds = presShell->GetRootFrame()->GetRect();
     }
   }
 
   nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryReferent(mWindow);
   RefPtr<DOMRect> rect = new DOMRect(window);
-  rect->SetRect(nsPresContext::AppUnitsToFloatCSSPixels(bounds.X()),
-                nsPresContext::AppUnitsToFloatCSSPixels(bounds.Y()),
+  rect->SetRect(nsPresContext::AppUnitsToFloatCSSPixels(bounds.x),
+                nsPresContext::AppUnitsToFloatCSSPixels(bounds.y),
                 nsPresContext::AppUnitsToFloatCSSPixels(bounds.Width()),
                 nsPresContext::AppUnitsToFloatCSSPixels(bounds.Height()));
   rect.forget(aResult);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDOMWindowUtils::GetIMEIsOpen(bool *aState)
--- a/dom/base/nsFocusManager.cpp
+++ b/dom/base/nsFocusManager.cpp
@@ -2630,17 +2630,18 @@ nsFocusManager::GetSelectionLocation(nsI
             nsRect caretRect;
             nsIFrame *frame = nsCaret::GetGeometry(domSelection, &caretRect);
             if (frame) {
               nsPoint caretWidgetOffset;
               nsIWidget *widget = frame->GetNearestWidget(caretWidgetOffset);
               caretRect.MoveBy(caretWidgetOffset);
               nsPoint newCaretOffset;
               nsIWidget *newCaretWidget = newCaretFrame->GetNearestWidget(newCaretOffset);
-              if (widget == newCaretWidget && caretRect.IsEqualXY(newCaretOffset.x, newCaretOffset.y)) {
+              if (widget == newCaretWidget && caretRect.y == newCaretOffset.y &&
+                  caretRect.x == newCaretOffset.x) {
                 // The caret is at the start of the new element.
                 startFrame = newCaretFrame;
                 startContent = newCaretContent;
                 if (endOfSelectionInStartNode) {
                   endContent = newCaretContent; // Ensure end of selection is not before start
                 }
               }
             }
--- a/dom/base/nsFrameLoader.cpp
+++ b/dom/base/nsFrameLoader.cpp
@@ -2469,20 +2469,18 @@ nsFrameLoader::GetWindowDimensions(nsInt
 
   nsCOMPtr<nsIDocShellTreeOwner> parentOwner;
   if (NS_FAILED(parentAsItem->GetTreeOwner(getter_AddRefs(parentOwner))) ||
       !parentOwner) {
     return NS_ERROR_FAILURE;
   }
 
   nsCOMPtr<nsIBaseWindow> treeOwnerAsWin(do_GetInterface(parentOwner));
-  int32_t x, y, width, height;
-  treeOwnerAsWin->GetPosition(&x, &y);
-  treeOwnerAsWin->GetSize(&width, &height);
-  aRect.SetRect(x, y, width, height);
+  treeOwnerAsWin->GetPosition(&aRect.x, &aRect.y);
+  treeOwnerAsWin->GetSize(&aRect.width, &aRect.height);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsFrameLoader::UpdatePositionAndSize(nsSubDocumentFrame *aIFrame)
 {
   if (IsRemoteFrame()) {
     if (mRemoteBrowser) {
--- a/dom/base/nsGlobalWindowOuter.cpp
+++ b/dom/base/nsGlobalWindowOuter.cpp
@@ -3457,20 +3457,20 @@ nsGlobalWindowOuter::GetScreenXY(CallerT
   dc->GetRect(screenRect);
   LayoutDeviceRect screenRectDev =
     LayoutDevicePixel::FromAppUnits(screenRect, dc->AppUnitsPerDevPixel());
 
   DesktopToLayoutDeviceScale scale = dc->GetDesktopToDeviceScale();
   DesktopRect screenRectDesk = screenRectDev / scale;
 
   CSSPoint cssPt =
-    LayoutDevicePoint(x - screenRectDev.X(), y - screenRectDev.Y()) /
+    LayoutDevicePoint(x - screenRectDev.x, y - screenRectDev.y) /
     presContext->CSSToDevPixelScale();
-  cssPt.x += screenRectDesk.X();
-  cssPt.y += screenRectDesk.Y();
+  cssPt.x += screenRectDesk.x;
+  cssPt.y += screenRectDesk.y;
 
   return CSSIntPoint(NSToIntRound(cssPt.x), NSToIntRound(cssPt.y));
 }
 
 int32_t
 nsGlobalWindowOuter::GetScreenXOuter(CallerType aCallerType, ErrorResult& aError)
 {
   return GetScreenXY(aCallerType, aError).x;
@@ -3505,29 +3505,29 @@ float
 nsGlobalWindowOuter::GetMozInnerScreenXOuter(CallerType aCallerType)
 {
   // When resisting fingerprinting, always return 0.
   if (nsContentUtils::ResistFingerprinting(aCallerType)) {
     return 0.0;
   }
 
   nsRect r = GetInnerScreenRect();
-  return nsPresContext::AppUnitsToFloatCSSPixels(r.X());
+  return nsPresContext::AppUnitsToFloatCSSPixels(r.x);
 }
 
 float
 nsGlobalWindowOuter::GetMozInnerScreenYOuter(CallerType aCallerType)
 {
   // Return 0 to prevent fingerprinting.
   if (nsContentUtils::ResistFingerprinting(aCallerType)) {
     return 0.0;
   }
 
   nsRect r = GetInnerScreenRect();
-  return nsPresContext::AppUnitsToFloatCSSPixels(r.Y());
+  return nsPresContext::AppUnitsToFloatCSSPixels(r.y);
 }
 
 double
 nsGlobalWindowOuter::GetDevicePixelRatioOuter(CallerType aCallerType)
 {
   if (!mDocShell) {
     return 1.0;
   }
--- a/dom/base/nsQueryContentEventResult.cpp
+++ b/dom/base/nsQueryContentEventResult.cpp
@@ -118,17 +118,17 @@ nsQueryContentEventResult::GetReversed(b
 }
 
 NS_IMETHODIMP
 nsQueryContentEventResult::GetLeft(int32_t *aLeft)
 {
   NS_ENSURE_TRUE(mSucceeded, NS_ERROR_NOT_AVAILABLE);
   NS_ENSURE_TRUE(IsRectRelatedPropertyAvailable(mEventMessage),
                  NS_ERROR_NOT_AVAILABLE);
-  *aLeft = mRect.X();
+  *aLeft = mRect.x;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsQueryContentEventResult::GetWidth(int32_t *aWidth)
 {
   NS_ENSURE_TRUE(mSucceeded, NS_ERROR_NOT_AVAILABLE);
   NS_ENSURE_TRUE(IsRectRelatedPropertyAvailable(mEventMessage),
@@ -138,17 +138,17 @@ nsQueryContentEventResult::GetWidth(int3
 }
 
 NS_IMETHODIMP
 nsQueryContentEventResult::GetTop(int32_t *aTop)
 {
   NS_ENSURE_TRUE(mSucceeded, NS_ERROR_NOT_AVAILABLE);
   NS_ENSURE_TRUE(IsRectRelatedPropertyAvailable(mEventMessage),
                  NS_ERROR_NOT_AVAILABLE);
-  *aTop = mRect.Y();
+  *aTop = mRect.y;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsQueryContentEventResult::GetHeight(int32_t *aHeight)
 {
   NS_ENSURE_TRUE(mSucceeded, NS_ERROR_NOT_AVAILABLE);
   NS_ENSURE_TRUE(IsRectRelatedPropertyAvailable(mEventMessage),
@@ -209,18 +209,18 @@ nsQueryContentEventResult::GetCharacterR
   NS_ENSURE_TRUE(mSucceeded, NS_ERROR_NOT_AVAILABLE);
   NS_ENSURE_TRUE(mEventMessage == eQueryTextRectArray,
                  NS_ERROR_NOT_AVAILABLE);
 
   if (NS_WARN_IF(mRectArray.Length() <= static_cast<uint32_t>(aOffset))) {
     return NS_ERROR_FAILURE;
   }
 
-  *aLeft = mRectArray[aOffset].X();
-  *aTop = mRectArray[aOffset].Y();
+  *aLeft = mRectArray[aOffset].x;
+  *aTop = mRectArray[aOffset].y;
   *aWidth = mRectArray[aOffset].Width();
   *aHeight = mRectArray[aOffset].Height();
 
   return NS_OK;
 }
 
 void
 nsQueryContentEventResult::SetEventResult(nsIWidget* aWidget,
--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -3213,28 +3213,30 @@ nsRange::CreateContextualFragment(const 
 static void ExtractRectFromOffset(nsIFrame* aFrame,
                                   const int32_t aOffset, nsRect* aR, bool aKeepLeft,
                                   bool aClampToEdge)
 {
   nsPoint point;
   aFrame->GetPointFromOffset(aOffset, &point);
 
   if (!aClampToEdge && !aR->Contains(point)) {
-    aR->SetRectX(point.x, 0);
+    aR->SetWidth(0);
+    aR->x = point.x;
     return;
   }
 
   if (aClampToEdge) {
     point = aR->ClampPoint(point);
   }
 
   if (aKeepLeft) {
-    aR->SetRightEdge(point.x);
+    aR->SetWidth(point.x - aR->x);
   } else {
-    aR->SetLeftEdge(point.x);
+    aR->SetWidth(aR->XMost() - point.x);
+    aR->x = point.x;
   }
 }
 
 static nsTextFrame*
 GetTextFrameForContent(nsIContent* aContent, bool aFlushLayout)
 {
   nsIDocument* doc = aContent->OwnerDoc();
   nsIPresShell* presShell = doc->GetShell();
--- a/dom/base/nsScreen.cpp
+++ b/dom/base/nsScreen.cpp
@@ -128,20 +128,22 @@ nsScreen::GetRect(nsRect& aRect)
 
   context->GetRect(aRect);
   LayoutDevicePoint screenTopLeftDev =
     LayoutDevicePixel::FromAppUnits(aRect.TopLeft(),
                                     context->AppUnitsPerDevPixel());
   DesktopPoint screenTopLeftDesk =
     screenTopLeftDev / context->GetDesktopToDeviceScale();
 
-  aRect.SetRect(NSToIntRound(screenTopLeftDesk.x),
-                NSToIntRound(screenTopLeftDesk.y),
-                nsPresContext::AppUnitsToIntCSSPixels(aRect.Height()),
-                nsPresContext::AppUnitsToIntCSSPixels(aRect.Width()));
+  aRect.x = NSToIntRound(screenTopLeftDesk.x);
+  aRect.y = NSToIntRound(screenTopLeftDesk.y);
+
+  aRect.SetHeight(nsPresContext::AppUnitsToIntCSSPixels(aRect.Height()));
+  aRect.SetWidth(nsPresContext::AppUnitsToIntCSSPixels(aRect.Width()));
+
   return NS_OK;
 }
 
 nsresult
 nsScreen::GetAvailRect(nsRect& aRect)
 {
   // Return window inner rect to prevent fingerprinting.
   if (ShouldResistFingerprinting()) {
@@ -159,22 +161,24 @@ nsScreen::GetAvailRect(nsRect& aRect)
   LayoutDevicePoint screenTopLeftDev =
     LayoutDevicePixel::FromAppUnits(r.TopLeft(),
                                     context->AppUnitsPerDevPixel());
   DesktopPoint screenTopLeftDesk =
     screenTopLeftDev / context->GetDesktopToDeviceScale();
 
   context->GetClientRect(aRect);
 
-  aRect.SetRect(NSToIntRound(screenTopLeftDesk.x) +
-                  nsPresContext::AppUnitsToIntCSSPixels(aRect.X() - r.X()),
-                NSToIntRound(screenTopLeftDesk.y) +
-                  nsPresContext::AppUnitsToIntCSSPixels(aRect.Y() - r.Y()),
-                nsPresContext::AppUnitsToIntCSSPixels(aRect.Height()),
-                nsPresContext::AppUnitsToIntCSSPixels(aRect.Width()));
+  aRect.x = NSToIntRound(screenTopLeftDesk.x) +
+            nsPresContext::AppUnitsToIntCSSPixels(aRect.x - r.x);
+  aRect.y = NSToIntRound(screenTopLeftDesk.y) +
+            nsPresContext::AppUnitsToIntCSSPixels(aRect.y - r.y);
+
+  aRect.SetHeight(nsPresContext::AppUnitsToIntCSSPixels(aRect.Height()));
+  aRect.SetWidth(nsPresContext::AppUnitsToIntCSSPixels(aRect.Width()));
+
   return NS_OK;
 }
 
 mozilla::dom::ScreenOrientation*
 nsScreen::Orientation() const
 {
   return mScreenOrientation;
 }
@@ -314,28 +318,25 @@ JSObject*
 nsScreen::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
 {
   return ScreenBinding::Wrap(aCx, this, aGivenProto);
 }
 
 nsresult
 nsScreen::GetWindowInnerRect(nsRect& aRect)
 {
-  aRect.MoveTo(0, 0);
+  aRect.x = 0;
+  aRect.y = 0;
   nsCOMPtr<nsPIDOMWindowInner> win = GetOwner();
   if (!win) {
     return NS_ERROR_FAILURE;
   }
-  nscoord width, height;
-  nsresult rv = win->GetInnerWidth(&width);
-  aRect.SetWidth(width);
+  nsresult rv = win->GetInnerWidth(&aRect.width);
   NS_ENSURE_SUCCESS(rv, rv);
-  rv = win->GetInnerHeight(&height);
-  aRect.SetHeight(height);
-  return rv;
+  return win->GetInnerHeight(&aRect.height);
 }
 
 bool nsScreen::ShouldResistFingerprinting() const
 {
   bool resist = false;
   nsCOMPtr<nsPIDOMWindowInner> owner = GetOwner();
   if (owner) {
     resist = nsContentUtils::ShouldResistFingerprinting(owner->GetDocShell());
--- a/dom/base/nsScreen.h
+++ b/dom/base/nsScreen.h
@@ -35,24 +35,24 @@ public:
   }
 
   nsPIDOMWindowOuter* GetOuter() const;
 
   int32_t GetTop(ErrorResult& aRv)
   {
     nsRect rect;
     aRv = GetRect(rect);
-    return rect.Y();
+    return rect.y;
   }
 
   int32_t GetLeft(ErrorResult& aRv)
   {
     nsRect rect;
     aRv = GetRect(rect);
-    return rect.X();
+    return rect.x;
   }
 
   int32_t GetWidth(ErrorResult& aRv)
   {
     nsRect rect;
     if (IsDeviceSizePageSize()) {
       if (nsCOMPtr<nsPIDOMWindowInner> owner = GetOwner()) {
         int32_t innerWidth = 0;
@@ -85,24 +85,24 @@ public:
   {
     return GetPixelDepth(aRv);
   }
 
   int32_t GetAvailTop(ErrorResult& aRv)
   {
     nsRect rect;
     aRv = GetAvailRect(rect);
-    return rect.Y();
+    return rect.y;
   }
 
   int32_t GetAvailLeft(ErrorResult& aRv)
   {
     nsRect rect;
     aRv = GetAvailRect(rect);
-    return rect.X();
+    return rect.x;
   }
 
   int32_t GetAvailWidth(ErrorResult& aRv)
   {
     nsRect rect;
     aRv = GetAvailRect(rect);
     return rect.Width();
   }
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -420,17 +420,17 @@ public:
     }
 
     Matrix transform =
       mFinalTarget->GetTransform().PostTranslate(-aRect.TopLeft() + mOffset);
 
     dt->SetTransform(transform);
 
     if (transform.Invert()) {
-      gfx::Rect dtBounds(0, 0, aRect.Width(), aRect.Height());
+      gfx::Rect dtBounds(0, 0, aRect.width, aRect.height);
       gfx::Rect fillRect = transform.TransformBounds(dtBounds);
       dt->FillRect(fillRect, CanvasGeneralPattern().ForStyle(mCtx, aStyle, dt));
     }
     return dt->Snapshot();
   }
 
   ~AdjustedTargetForFilter()
   {
@@ -1482,17 +1482,17 @@ bool CanvasRenderingContext2D::SwitchRen
   mRenderingMode = attemptedMode;
 
   return true;
 }
 
 bool
 CanvasRenderingContext2D::CopyBufferProvider(PersistentBufferProvider& aOld,
                                              DrawTarget& aTarget,
-                                             const IntRect& aCopyRect)
+                                             IntRect aCopyRect)
 {
   // Borrowing the snapshot must be done after ReturnTarget.
   RefPtr<SourceSurface> snapshot = aOld.BorrowSnapshot();
 
   if (!snapshot) {
     return false;
   }
 
@@ -4212,17 +4212,17 @@ CanvasRenderingContext2D::AddHitRegion(c
 
   if (!path) {
     aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
     return;
   }
 
   // get the bounds of the current path. They are relative to the canvas
   gfx::Rect bounds(path->GetBounds(mTarget->GetTransform()));
-  if (bounds.IsZeroArea() || !bounds.IsFinite()) {
+  if ((bounds.width == 0) || (bounds.height == 0) || !bounds.IsFinite()) {
     // The specified region has no pixels.
     aError.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
     return;
   }
 
   // remove old hit region first
   RemoveHitRegion(aOptions.mId);
 
@@ -4276,17 +4276,17 @@ CanvasRenderingContext2D::ClearHitRegion
 
 bool
 CanvasRenderingContext2D::GetHitRegionRect(Element* aElement, nsRect& aRect)
 {
   for (unsigned int x = 0; x < mHitRegionsOptions.Length(); x++) {
     RegionInfo& info = mHitRegionsOptions[x];
     if (info.mElement == aElement) {
       gfx::Rect bounds(info.mPath->GetBounds());
-      gfxRect rect(bounds.X(), bounds.Y(), bounds.Width(), bounds.Height());
+      gfxRect rect(bounds.x, bounds.y, bounds.width, bounds.height);
       aRect = nsLayoutUtils::RoundGfxRectToAppRect(rect, AppUnitsPerCSSPixel());
 
       return true;
     }
   }
 
   return false;
 }
@@ -4741,17 +4741,17 @@ CanvasRenderingContext2D::DrawOrMeasureT
       baselineAnchor -= (fontMetrics.emAscent - fontMetrics.emDescent) * .5f;
     }
     processor.mPt.x -= baselineAnchor;
   } else {
     processor.mPt.y += baselineAnchor;
   }
 
   // correct bounding box to get it to be the correct size/position
-  processor.mBoundingBox.SetWidth(totalWidth);
+  processor.mBoundingBox.width = totalWidth;
   processor.mBoundingBox.MoveBy(gfxPoint(processor.mPt.x, processor.mPt.y));
 
   processor.mPt.x *= processor.mAppUnitsPerDevPixel;
   processor.mPt.y *= processor.mAppUnitsPerDevPixel;
 
   EnsureTarget();
   if (!IsTargetValid()) {
     return NS_ERROR_FAILURE;
@@ -5398,64 +5398,64 @@ CanvasRenderingContext2D::DrawImage(cons
 }
 
 void
 CanvasRenderingContext2D::DrawDirectlyToCanvas(
                           const nsLayoutUtils::DirectDrawInfo& aImage,
                           gfx::Rect* aBounds,
                           gfx::Rect aDest,
                           gfx::Rect aSrc,
-                          const gfx::IntSize& aImgSize)
-{
-  MOZ_ASSERT(!aSrc.IsEmpty(), "Need positive source width and height");
+                          gfx::IntSize aImgSize)
+{
+  MOZ_ASSERT(aSrc.width > 0 && aSrc.height > 0,
+             "Need positive source width and height");
 
   AdjustedTarget tempTarget(this, aBounds->IsEmpty() ? nullptr: aBounds);
   if (!tempTarget) {
     return;
   }
 
   // Get any existing transforms on the context, including transformations used
   // for context shadow.
   Matrix matrix = tempTarget->GetTransform();
   gfxMatrix contextMatrix = ThebesMatrix(matrix);
   gfxSize contextScale(contextMatrix.ScaleFactors(true));
 
   // Scale the dest rect to include the context scale.
   aDest.Scale(contextScale.width, contextScale.height);
 
   // Scale the image size to the dest rect, and adjust the source rect to match.
-  gfxSize scale(aDest.Width() / aSrc.Width(), aDest.Height() / aSrc.Height());
+  gfxSize scale(aDest.width / aSrc.width, aDest.height / aSrc.height);
   IntSize scaledImageSize = IntSize::Ceil(aImgSize.width * scale.width,
                                           aImgSize.height * scale.height);
   aSrc.Scale(scale.width, scale.height);
 
   // We're wrapping tempTarget's (our) DrawTarget here, so we need to restore
   // the matrix even though this is a temp gfxContext.
   AutoRestoreTransform autoRestoreTransform(mTarget);
 
   RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempTarget);
   if (!context) {
     gfxDevCrash(LogReason::InvalidContext) << "Canvas context problem";
     return;
   }
   context->SetMatrixDouble(contextMatrix.
                            PreScale(1.0 / contextScale.width,
                                     1.0 / contextScale.height).
-                           PreTranslate(aDest.X() - aSrc.X(),
-                                        aDest.Y() - aSrc.Y()));
+                           PreTranslate(aDest.x - aSrc.x, aDest.y - aSrc.y));
 
   // FLAG_CLAMP is added for increased performance, since we never tile here.
   uint32_t modifiedFlags = aImage.mDrawingFlags | imgIContainer::FLAG_CLAMP;
 
   CSSIntSize sz(scaledImageSize.width, scaledImageSize.height); // XXX hmm is scaledImageSize really in CSS pixels?
   SVGImageContext svgContext(Some(sz));
 
   auto result = aImage.mImgContainer->
     Draw(context, scaledImageSize,
-         ImageRegion::Create(gfxRect(aSrc.X(), aSrc.Y(), aSrc.Width(), aSrc.Height())),
+         ImageRegion::Create(gfxRect(aSrc.x, aSrc.y, aSrc.width, aSrc.height)),
          aImage.mWhichFrame, SamplingFilter::GOOD, Some(svgContext), modifiedFlags, CurrentState().globalAlpha);
 
   if (result != ImgDrawResult::SUCCESS) {
     NS_WARNING("imgIContainer::Draw failed");
   }
 }
 
 void
@@ -5893,25 +5893,25 @@ CanvasRenderingContext2D::GetImageDataAr
 
   do {
     JS::AutoCheckCannotGC nogc;
     bool isShared;
     uint8_t* data = JS_GetUint8ClampedArrayData(darray, &isShared, nogc);
     MOZ_ASSERT(!isShared);        // Should not happen, data was created above
 
     uint32_t srcStride = rawData.mStride;
-    uint8_t* src = rawData.mData + srcReadRect.Y() * srcStride + srcReadRect.X() * 4;
+    uint8_t* src = rawData.mData + srcReadRect.y * srcStride + srcReadRect.x * 4;
 
     // Return all-white, opaque pixel data if no permission.
     if (usePlaceholder) {
       memset(data, 0xFF, len.value());
       break;
     }
 
-    uint8_t* dst = data + dstWriteRect.Y() * (aWidth * 4) + dstWriteRect.X() * 4;
+    uint8_t* dst = data + dstWriteRect.y * (aWidth * 4) + dstWriteRect.x * 4;
 
     if (mOpaque) {
       SwizzleData(src, srcStride, SurfaceFormat::X8R8G8B8_UINT32,
                   dst, aWidth * 4, SurfaceFormat::R8G8B8A8,
                   dstWriteRect.Size());
     } else {
       UnpremultiplyData(src, srcStride, SurfaceFormat::A8R8G8B8_UINT32,
                         dst, aWidth * 4, SurfaceFormat::R8G8B8A8,
@@ -6061,17 +6061,17 @@ CanvasRenderingContext2D::PutImageData_e
   DataSourceSurface::MappedSurface map;
   RefPtr<DataSourceSurface> sourceSurface;
   uint8_t* lockedBits = nullptr;
   uint8_t* dstData;
   IntSize dstSize;
   int32_t dstStride;
   SurfaceFormat dstFormat;
   if (mTarget->LockBits(&lockedBits, &dstSize, &dstStride, &dstFormat)) {
-    dstData = lockedBits + dirtyRect.Y() * dstStride + dirtyRect.X() * 4;
+    dstData = lockedBits + dirtyRect.y * dstStride + dirtyRect.x * 4;
   } else {
     sourceSurface =
       Factory::CreateDataSourceSurface(dirtyRect.Size(),
                                        SurfaceFormat::B8G8R8A8,
                                        false);
 
     // In certain scenarios, requesting larger than 8k image fails.  Bug 803568
     // covers the details of how to run into it, but the full detailed
@@ -6088,31 +6088,31 @@ CanvasRenderingContext2D::PutImageData_e
     if (!dstData) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     dstStride = map.mStride;
     dstFormat = sourceSurface->GetFormat();
   }
 
   IntRect srcRect = dirtyRect - IntPoint(aX, aY);
-  uint8_t* srcData = aArray->Data() + srcRect.Y() * (aW * 4) + srcRect.X() * 4;
+  uint8_t* srcData = aArray->Data() + srcRect.y * (aW * 4) + srcRect.x * 4;
 
   PremultiplyData(srcData, aW * 4, SurfaceFormat::R8G8B8A8,
                   dstData, dstStride,
                   mOpaque ? SurfaceFormat::X8R8G8B8_UINT32 : SurfaceFormat::A8R8G8B8_UINT32,
                   dirtyRect.Size());
 
   if (lockedBits) {
     mTarget->ReleaseBits(lockedBits);
   } else if (sourceSurface) {
     sourceSurface->Unmap();
     mTarget->CopySurface(sourceSurface, dirtyRect - dirtyRect.TopLeft(), dirtyRect.TopLeft());
   }
 
-  Redraw(gfx::Rect(dirtyRect.X(), dirtyRect.Y(), dirtyRect.Width(), dirtyRect.Height()));
+  Redraw(gfx::Rect(dirtyRect.x, dirtyRect.y, dirtyRect.width, dirtyRect.height));
 
   return NS_OK;
 }
 
 static already_AddRefed<ImageData>
 CreateImageData(JSContext* aCx, CanvasRenderingContext2D* aContext,
                 uint32_t aW, uint32_t aH, ErrorResult& aError)
 {
--- a/dom/canvas/CanvasRenderingContext2D.h
+++ b/dom/canvas/CanvasRenderingContext2D.h
@@ -564,17 +564,17 @@ protected:
 
   nsresult PutImageData_explicit(int32_t aX, int32_t aY, uint32_t aW, uint32_t aH,
                                  dom::Uint8ClampedArray* aArray,
                                  bool aHasDirtyRect, int32_t aDirtyX, int32_t aDirtyY,
                                  int32_t aDirtyWidth, int32_t aDirtyHeight);
 
   bool CopyBufferProvider(layers::PersistentBufferProvider& aOld,
                           gfx::DrawTarget& aTarget,
-                          const gfx::IntRect& aCopyRect);
+                          gfx::IntRect aCopyRect);
 
   /**
    * Internal method to complete initialisation, expects mTarget to have been set
    */
   nsresult Initialize(int32_t aWidth, int32_t aHeight);
 
   nsresult InitializeWithTarget(mozilla::gfx::DrawTarget* aSurface,
                                 int32_t aWidth, int32_t aHeight);
@@ -728,19 +728,19 @@ protected:
 
   void DrawImage(const CanvasImageSource& aImgElt,
                  double aSx, double aSy, double aSw, double aSh,
                  double aDx, double aDy, double aDw, double aDh,
                  uint8_t aOptional_argc, mozilla::ErrorResult& aError);
 
   void DrawDirectlyToCanvas(const nsLayoutUtils::DirectDrawInfo& aImage,
                             mozilla::gfx::Rect* aBounds,
-                            mozilla::gfx::Rect aDest, // Modified locally
-                            mozilla::gfx::Rect aSrc,  // for easier computation
-                            const gfx::IntSize& aImgSize);
+                            mozilla::gfx::Rect aDest,
+                            mozilla::gfx::Rect aSrc,
+                            gfx::IntSize aImgSize);
 
   nsString& GetFont()
   {
     /* will initilize the value if not set, else does nothing */
     GetCurrentFontStyle();
 
     return CurrentState().font;
   }
--- a/dom/canvas/ImageBitmap.cpp
+++ b/dom/canvas/ImageBitmap.cpp
@@ -156,36 +156,38 @@ ImageBitmapShutdownObserver::Observe(nsI
  * and height.
  */
 static IntRect
 FixUpNegativeDimension(const IntRect& aRect, ErrorResult& aRv)
 {
   gfx::IntRect rect = aRect;
 
   // fix up negative dimensions
-  if (rect.Width() < 0) {
-    CheckedInt32 checkedX = CheckedInt32(rect.X()) + rect.Width();
+  if (rect.width < 0) {
+    CheckedInt32 checkedX = CheckedInt32(rect.x) + rect.width;
 
     if (!checkedX.isValid()) {
       aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
       return rect;
     }
 
-    rect.SetRectX(checkedX.value(), -rect.Width());
+    rect.x = checkedX.value();
+    rect.width = -(rect.width);
   }
 
-  if (rect.Height() < 0) {
-    CheckedInt32 checkedY = CheckedInt32(rect.Y()) + rect.Height();
+  if (rect.height < 0) {
+    CheckedInt32 checkedY = CheckedInt32(rect.y) + rect.height;
 
     if (!checkedY.isValid()) {
       aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
       return rect;
     }
 
-    rect.SetRectY(checkedY.value(), -rect.Height());
+    rect.y = checkedY.value();
+    rect.height = -(rect.height);
   }
 
   return rect;
 }
 
 /*
  * This helper function copies the data of the given DataSourceSurface,
  *  _aSurface_, in the given area, _aCropRect_, into a new DataSourceSurface.
@@ -213,18 +215,18 @@ CropAndCopyDataSourceSurface(DataSourceS
   // We cannot keep using aSurface->GetFormat() to create new DataSourceSurface,
   // since it might be SurfaceFormat::B8G8R8X8 which does not handle opacity,
   // however the specification explicitly define that "If any of the pixels on
   // this rectangle are outside the area where the input bitmap was placed, then
   // they will be transparent black in output."
   // So, instead, we force the output format to be SurfaceFormat::B8G8R8A8.
   const SurfaceFormat format = SurfaceFormat::B8G8R8A8;
   const int bytesPerPixel = BytesPerPixel(format);
-  const IntSize dstSize = IntSize(positiveCropRect.Width(),
-                                  positiveCropRect.Height());
+  const IntSize dstSize = IntSize(positiveCropRect.width,
+                                  positiveCropRect.height);
   const uint32_t dstStride = dstSize.width * bytesPerPixel;
 
   // Create a new SourceSurface.
   RefPtr<DataSourceSurface> dstDataSurface =
     Factory::CreateDataSourceSurfaceWithStride(dstSize, format, dstStride, true);
 
   if (NS_WARN_IF(!dstDataSurface)) {
     return nullptr;
@@ -241,28 +243,27 @@ CropAndCopyDataSourceSurface(DataSourceS
     // Copy the raw data into the newly created DataSourceSurface.
     DataSourceSurface::ScopedMap srcMap(aSurface, DataSourceSurface::READ);
     DataSourceSurface::ScopedMap dstMap(dstDataSurface, DataSourceSurface::WRITE);
     if (NS_WARN_IF(!srcMap.IsMapped()) ||
         NS_WARN_IF(!dstMap.IsMapped())) {
       return nullptr;
     }
 
-    uint8_t* srcBufferPtr = srcMap.GetData() + surfPortion.Y() * srcMap.GetStride()
-                                             + surfPortion.X() * bytesPerPixel;
+    uint8_t* srcBufferPtr = srcMap.GetData() + surfPortion.y * srcMap.GetStride()
+                                             + surfPortion.x * bytesPerPixel;
     uint8_t* dstBufferPtr = dstMap.GetData() + dest.y * dstMap.GetStride()
                                              + dest.x * bytesPerPixel;
     CheckedInt<uint32_t> copiedBytesPerRaw =
-      CheckedInt<uint32_t>(surfPortion.Width()) * bytesPerPixel;
+      CheckedInt<uint32_t>(surfPortion.width) * bytesPerPixel;
     if (!copiedBytesPerRaw.isValid()) {
       return nullptr;
     }
 
-    auto surfPortionHeight = surfPortion.Height();
-    for (int i = 0; i < surfPortionHeight; ++i) {
+    for (int i = 0; i < surfPortion.height; ++i) {
       memcpy(dstBufferPtr, srcBufferPtr, copiedBytesPerRaw.value());
       srcBufferPtr += srcMap.GetStride();
       dstBufferPtr += dstMap.GetStride();
     }
   }
 
   return dstDataSurface.forget();
 }
@@ -1524,20 +1525,20 @@ ImageBitmap::ReadStructuredClone(JSConte
 /*static*/ bool
 ImageBitmap::WriteStructuredClone(JSStructuredCloneWriter* aWriter,
                                   nsTArray<RefPtr<DataSourceSurface>>& aClonedSurfaces,
                                   ImageBitmap* aImageBitmap)
 {
   MOZ_ASSERT(aWriter);
   MOZ_ASSERT(aImageBitmap);
 
-  const uint32_t picRectX = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.X());
-  const uint32_t picRectY = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.Y());
-  const uint32_t picRectWidth = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.Width());
-  const uint32_t picRectHeight = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.Height());
+  const uint32_t picRectX = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.x);
+  const uint32_t picRectY = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.y);
+  const uint32_t picRectWidth = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.width);
+  const uint32_t picRectHeight = BitwiseCast<uint32_t>(aImageBitmap->mPictureRect.height);
   const uint32_t alphaType = BitwiseCast<uint32_t>(aImageBitmap->mAlphaType);
   const uint32_t isCroppingAreaOutSideOfSourceImage = aImageBitmap->mIsCroppingAreaOutSideOfSourceImage ? 1 : 0;
 
   // Indexing the cloned surfaces and send the index to the receiver.
   uint32_t index = aClonedSurfaces.Length();
 
   if (NS_WARN_IF(!JS_WriteUint32Pair(aWriter, SCTAG_DOM_IMAGEBITMAP, index)) ||
       NS_WARN_IF(!JS_WriteUint32Pair(aWriter, picRectX, picRectY)) ||
@@ -1825,17 +1826,17 @@ ImageBitmap::MapDataInto(JSContext* aCx,
 
   // Case 2:
   // If the image bitmap is going to be accessed in YUV422/YUV422 series with a
   // cropping area starts at an odd x or y coordinate.
   if (aFormat == ImageBitmapFormat::YUV422P ||
       aFormat == ImageBitmapFormat::YUV420P ||
       aFormat == ImageBitmapFormat::YUV420SP_NV12 ||
       aFormat == ImageBitmapFormat::YUV420SP_NV21) {
-    if ((mPictureRect.X() & 1) || (mPictureRect.Y() & 1)) {
+    if ((mPictureRect.x & 1) || (mPictureRect.y & 1)) {
       aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
       return promise.forget();
     }
   }
 
   AsyncMapDataIntoBufferSource(aCx, promise, this, aBuffer, aOffset, aFormat);
   return promise.forget();
 }
--- a/dom/events/ContentEventHandler.cpp
+++ b/dom/events/ContentEventHandler.cpp
@@ -1565,25 +1565,25 @@ ContentEventHandler::OnQueryTextContent(
   return NS_OK;
 }
 
 void
 ContentEventHandler::EnsureNonEmptyRect(nsRect& aRect) const
 {
   // See the comment in ContentEventHandler.h why this doesn't set them to
   // one device pixel.
-  aRect.SetHeight(std::max(1, aRect.Height()));
-  aRect.SetWidth(std::max(1, aRect.Width()));
+  aRect.height = std::max(1, aRect.height);
+  aRect.width = std::max(1, aRect.width);
 }
 
 void
 ContentEventHandler::EnsureNonEmptyRect(LayoutDeviceIntRect& aRect) const
 {
-  aRect.SetHeight(std::max(1, aRect.Height()));
-  aRect.SetWidth(std::max(1, aRect.Width()));
+  aRect.height = std::max(1, aRect.height);
+  aRect.width = std::max(1, aRect.width);
 }
 
 ContentEventHandler::NodePosition
 ContentEventHandler::GetNodePositionHavingFlatText(
                        const NodePosition& aNodePosition)
 {
   return GetNodePositionHavingFlatText(aNodePosition.Container(),
                                        aNodePosition.Offset());
@@ -1823,24 +1823,24 @@ ContentEventHandler::GetLineBreakerRectB
   if (NS_WARN_IF(!fontMetrics)) {
     return FrameRelativeRect();
   }
 
   const WritingMode kWritingMode = frameForFontMetrics->GetWritingMode();
   nscoord baseline = aFrame->GetCaretBaseline();
   if (kWritingMode.IsVertical()) {
     if (kWritingMode.IsLineInverted()) {
-      result.mRect.MoveToX(baseline - fontMetrics->MaxDescent());
+      result.mRect.x = baseline - fontMetrics->MaxDescent();
     } else {
-      result.mRect.MoveToX(baseline - fontMetrics->MaxAscent());
+      result.mRect.x = baseline - fontMetrics->MaxAscent();
     }
-    result.mRect.SetWidth(fontMetrics->MaxHeight());
+    result.mRect.width = fontMetrics->MaxHeight();
   } else {
-    result.mRect.SetRectY(baseline - fontMetrics->MaxAscent(),
-                          fontMetrics->MaxHeight());
+    result.mRect.y = baseline - fontMetrics->MaxAscent();
+    result.mRect.height = fontMetrics->MaxHeight();
   }
 
   // If aFrame isn't a <br> frame, caret should be at outside of it because
   // the line break is before its open tag.  For example, case of
   // |<div><p>some text</p></div>|, caret is before <p> element and in <div>
   // element, the caret should be left of top-left corner of <p> element like:
   //
   // +-<div>-------------------  <div>'s border box
@@ -1851,25 +1851,26 @@ ContentEventHandler::GetLineBreakerRectB
   //   ^- caret
   //
   // However, this is a hack for unusual scenario.  This hack shouldn't be
   // used as far as possible.
   if (!aFrame->IsBrFrame()) {
     if (kWritingMode.IsVertical()) {
       if (kWritingMode.IsLineInverted()) {
         // above of top-left corner of aFrame.
-        result.mRect.MoveToX(0);
+        result.mRect.x = 0;
       } else {
         // above of top-right corner of aFrame.
-        result.mRect.MoveToX(aFrame->GetRect().XMost() - result.mRect.Width());
+        result.mRect.x = aFrame->GetRect().XMost() - result.mRect.width;
       }
       result.mRect.y = -aFrame->PresContext()->AppUnitsPerDevPixel();
     } else {
       // left of top-left corner of aFrame.
-      result.mRect.MoveTo(-aFrame->PresContext()->AppUnitsPerDevPixel(), 0);
+      result.mRect.x = -aFrame->PresContext()->AppUnitsPerDevPixel();
+      result.mRect.y = 0;
     }
   }
   return result;
 }
 
 ContentEventHandler::FrameRelativeRect
 ContentEventHandler::GuessLineBreakerRectAfter(nsIContent* aTextContent)
 {
@@ -1888,22 +1889,22 @@ ContentEventHandler::GuessLineBreakerRec
   nsIFrame* lastTextFrame = nullptr;
   nsresult rv = GetFrameForTextRect(aTextContent, length, true, &lastTextFrame);
   if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!lastTextFrame)) {
     return result;
   }
   const nsRect kLastTextFrameRect = lastTextFrame->GetRect();
   if (lastTextFrame->GetWritingMode().IsVertical()) {
     // Below of the last text frame.
-    result.mRect.SetRect(0, kLastTextFrameRect.Height(),
-                         kLastTextFrameRect.Width(), 0);
+    result.mRect.SetRect(0, kLastTextFrameRect.height,
+                         kLastTextFrameRect.width, 0);
   } else {
     // Right of the last text frame (not bidi-aware).
-    result.mRect.SetRect(kLastTextFrameRect.Width(), 0,
-                         0, kLastTextFrameRect.Height());
+    result.mRect.SetRect(kLastTextFrameRect.width, 0,
+                         0, kLastTextFrameRect.height);
   }
   result.mBaseFrame = lastTextFrame;
   return result;
 }
 
 ContentEventHandler::FrameRelativeRect
 ContentEventHandler::GuessFirstCaretRectIn(nsIFrame* aFrame)
 {
@@ -1916,39 +1917,39 @@ ContentEventHandler::GuessFirstCaretRect
   RefPtr<nsFontMetrics> fontMetrics =
     nsLayoutUtils::GetInflatedFontMetricsForFrame(aFrame);
   const nscoord kMaxHeight =
     fontMetrics ? fontMetrics->MaxHeight() :
                   16 * presContext->AppUnitsPerDevPixel();
 
   nsRect caretRect;
   const nsRect kContentRect = aFrame->GetContentRect() - aFrame->GetPosition();
-  caretRect.MoveToY(kContentRect.Y());
+  caretRect.y = kContentRect.y;
   if (!kWritingMode.IsVertical()) {
     if (kWritingMode.IsBidiLTR()) {
-      caretRect.MoveToX(kContentRect.X());
+      caretRect.x = kContentRect.x;
     } else {
       // Move 1px left for the space of caret itself.
       const nscoord kOnePixel = presContext->AppUnitsPerDevPixel();
-      caretRect.MoveToX(kContentRect.XMost() - kOnePixel);
+      caretRect.x = kContentRect.XMost() - kOnePixel;
     }
-    caretRect.SetHeight(kMaxHeight);
+    caretRect.height = kMaxHeight;
     // However, don't add kOnePixel here because it may cause 2px width at
     // aligning the edge to device pixels.
-    caretRect.SetWidth(1);
+    caretRect.width = 1;
   } else {
     if (kWritingMode.IsVerticalLR()) {
-      caretRect.MoveToX(kContentRect.X());
+      caretRect.x = kContentRect.x;
     } else {
-      caretRect.MoveToX(kContentRect.XMost() - kMaxHeight);
+      caretRect.x = kContentRect.XMost() - kMaxHeight;
     }
-    caretRect.SetWidth(kMaxHeight);
+    caretRect.width = kMaxHeight;
     // Don't add app units for a device pixel because it may cause 2px height
     // at aligning the edge to device pixels.
-    caretRect.SetHeight(1);
+    caretRect.height = 1;
   }
   return FrameRelativeRect(caretRect, aFrame);
 }
 
 nsresult
 ContentEventHandler::OnQueryTextRectArray(WidgetQueryContentEvent* aEvent)
 {
   nsresult rv = Init(aEvent);
@@ -2093,20 +2094,22 @@ ContentEventHandler::OnQueryTextRectArra
       // use this path if it's a <br> frame because trusting <br> frame's rect
       // is better than guessing the rect from the previous character.)
       if (!firstFrame->IsBrFrame() && aEvent->mInput.mOffset != offset) {
         baseFrame = lastFrame;
         brRect = lastCharRect;
         if (!wasLineBreaker) {
           if (isVertical) {
             // Right of the last character.
-            brRect.SetRectY(brRect.YMost() + 1, 1);
+            brRect.y = brRect.YMost() + 1;
+            brRect.height = 1;
           } else {
             // Under the last character.
-            brRect.SetRectX(brRect.XMost() + 1, 1);
+            brRect.x = brRect.XMost() + 1;
+            brRect.width = 1;
           }
         }
       }
       // If it's not a <br> frame and it's the first character rect at the
       // queried range, we need to the previous character of the start of
       // the queried range if there is a text node.
       else if (!firstFrame->IsBrFrame() && lastTextContent) {
         FrameRelativeRect brRectRelativeToLastTextFrame =
@@ -2223,21 +2226,23 @@ ContentEventHandler::OnQueryTextRectArra
   // means that the offset is too large or the query range is collapsed.
   if (offset < kEndOffset || aEvent->mReply.mRectArray.IsEmpty()) {
     // If we've already retrieved some character rects before current offset,
     // we can guess the last rect from the last character's rect unless it's a
     // line breaker.  (If it's a line breaker, the caret rect is in next line.)
     if (!aEvent->mReply.mRectArray.IsEmpty() && !wasLineBreaker) {
       rect = aEvent->mReply.mRectArray.LastElement();
       if (isVertical) {
-        rect.SetRectY(rect.YMost() + 1, 1);
-        MOZ_ASSERT(rect.Width());
+        rect.y = rect.YMost() + 1;
+        rect.height = 1;
+        MOZ_ASSERT(rect.width);
       } else {
-        rect.SetRectX(rect.XMost() + 1, 1);
-        MOZ_ASSERT(rect.Height());
+        rect.x = rect.XMost() + 1;
+        rect.width = 1;
+        MOZ_ASSERT(rect.height);
       }
       aEvent->mReply.mRectArray.AppendElement(rect);
     } else {
       // Note that don't use eQueryCaretRect here because if caret is at the
       // end of the content, it returns actual caret rect instead of computing
       // the rect itself.  It means that the result depends on caret position.
       // So, we shouldn't use it for consistency result in automated tests.
       WidgetQueryContentEvent queryTextRect(eQueryTextRect, *aEvent);
@@ -2247,19 +2252,19 @@ ContentEventHandler::OnQueryTextRectArra
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
       if (NS_WARN_IF(!queryTextRect.mSucceeded)) {
         return NS_ERROR_FAILURE;
       }
       MOZ_ASSERT(!queryTextRect.mReply.mRect.IsEmpty());
       if (queryTextRect.mReply.mWritingMode.IsVertical()) {
-        queryTextRect.mReply.mRect.SetHeight(1);
+        queryTextRect.mReply.mRect.height = 1;
       } else {
-        queryTextRect.mReply.mRect.SetWidth(1);
+        queryTextRect.mReply.mRect.width = 1;
       }
       aEvent->mReply.mRectArray.AppendElement(queryTextRect.mReply.mRect);
     }
   }
 
   aEvent->mSucceeded = true;
   return NS_OK;
 }
@@ -2393,19 +2398,21 @@ ContentEventHandler::OnQueryTextRect(Wid
     rv = ConvertToRootRelativeOffset(firstFrame, rect);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
     frameRect = rect;
     // Exclude the rect before start point of the queried range.
     firstFrame->GetPointFromOffset(firstFrame.mOffsetInNode, &ptOffset);
     if (firstFrame->GetWritingMode().IsVertical()) {
-      rect.SetTopEdge(rect.Y() + ptOffset.y);
+      rect.y += ptOffset.y;
+      rect.height -= ptOffset.y;
     } else {
-      rect.SetLeftEdge(rect.X() + ptOffset.x);
+      rect.x += ptOffset.x;
+      rect.width -= ptOffset.x;
     }
   }
   // If first frame causes a line breaker but it's not a <br> frame, we cannot
   // compute proper rect only with the frame because typically caret is at
   // right of the last character of it.  For example, if caret is after "c" of
   // |<p>abc</p><p>def</p>|, IME may query a line breaker's rect after "c".
   // Then, if we compute it only with the 2nd <p>'s block frame, the result
   // will be:
@@ -2535,19 +2542,19 @@ ContentEventHandler::OnQueryTextRect(Wid
       return rv;
     }
   }
 
   // Shrink the last frame for cutting off the text after the query range.
   if (lastFrame->IsTextFrame()) {
     lastFrame->GetPointFromOffset(lastFrame.mOffsetInNode, &ptOffset);
     if (lastFrame->GetWritingMode().IsVertical()) {
-      frameRect.SetHeight(frameRect.Height() - lastFrame->GetRect().Height() + ptOffset.y);
+      frameRect.height -= lastFrame->GetRect().height - ptOffset.y;
     } else {
-      frameRect.SetWidth(frameRect.Width() - lastFrame->GetRect().Width() + ptOffset.x);
+      frameRect.width -= lastFrame->GetRect().width - ptOffset.x;
     }
     // UnionRect() requires non-empty rect.  So, let's make sure to get
     // non-empty rect from the last frame.
     EnsureNonEmptyRect(frameRect);
 
     if (firstFrame.mFrame == lastFrame.mFrame) {
       rect.IntersectRect(rect, frameRect);
     } else {
@@ -2622,19 +2629,19 @@ ContentEventHandler::OnQueryCaretRect(Wi
   queryTextRectEvent.InitForQueryTextRect(aEvent->mInput.mOffset, 1, options);
   rv = OnQueryTextRect(&queryTextRectEvent);
   if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!queryTextRectEvent.mSucceeded)) {
     return NS_ERROR_FAILURE;
   }
   queryTextRectEvent.mReply.mString.Truncate();
   aEvent->mReply = queryTextRectEvent.mReply;
   if (aEvent->GetWritingMode().IsVertical()) {
-    aEvent->mReply.mRect.SetHeight(1);
+    aEvent->mReply.mRect.height = 1;
   } else {
-    aEvent->mReply.mRect.SetWidth(1);
+    aEvent->mReply.mRect.width = 1;
   }
   // Returning empty rect may cause native IME confused, let's make sure to
   // return non-empty rect.
   aEvent->mSucceeded = true;
   return NS_OK;
 }
 
 nsresult
@@ -2801,19 +2808,18 @@ ContentEventHandler::OnQueryDOMWidgetHit
   NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE);
   nsIFrame* docFrame = shell->GetRootFrame();
   NS_ENSURE_TRUE(docFrame, NS_ERROR_FAILURE);
 
   LayoutDeviceIntPoint eventLoc =
     aEvent->mRefPoint + aEvent->mWidget->WidgetToScreenOffset();
   CSSIntRect docFrameRect = docFrame->GetScreenRect();
   CSSIntPoint eventLocCSS(
-    docFrame->PresContext()->DevPixelsToIntCSSPixels(eventLoc.x) - docFrameRect.X(),
-    docFrame->PresContext()->DevPixelsToIntCSSPixels(eventLoc.y) - docFrameRect.Y()
-    );
+    docFrame->PresContext()->DevPixelsToIntCSSPixels(eventLoc.x) - docFrameRect.x,
+    docFrame->PresContext()->DevPixelsToIntCSSPixels(eventLoc.y) - docFrameRect.y);
 
   Element* contentUnderMouse =
     mDocument->ElementFromPointHelper(eventLocCSS.x, eventLocCSS.y, false, false);
   if (contentUnderMouse) {
     nsIWidget* targetWidget = nullptr;
     nsIFrame* targetFrame = contentUnderMouse->GetPrimaryFrame();
     nsIObjectFrame* pluginFrame = do_QueryFrame(targetFrame);
     if (pluginFrame) {
--- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -2898,28 +2898,28 @@ EventStateManager::DecideGestureEvent(Wi
 #endif
 
     nsIScrollableFrame* scrollableFrame = do_QueryFrame(current);
     if (scrollableFrame) {
       if (current->IsFrameOfType(nsIFrame::eXULBox)) {
         displayPanFeedback = true;
 
         nsRect scrollRange = scrollableFrame->GetScrollRange();
-        bool canScrollHorizontally = scrollRange.Width() > 0;
+        bool canScrollHorizontally = scrollRange.width > 0;
 
         if (targetFrame->IsMenuFrame()) {
           // menu frames report horizontal scroll when they have submenus
           // and we don't want that
           canScrollHorizontally = false;
           displayPanFeedback = false;
         }
 
         // Vertical panning has priority over horizontal panning, so
         // when vertical movement is possible we can just finish the loop.
-        if (scrollRange.Height() > 0) {
+        if (scrollRange.height > 0) {
           panDirection = WidgetGestureNotifyEvent::ePanVertical;
           break;
         }
 
         if (canScrollHorizontally) {
           panDirection = WidgetGestureNotifyEvent::ePanHorizontal;
           displayPanFeedback = false;
         }
@@ -4383,18 +4383,18 @@ EventStateManager::NotifyMouseOver(Widge
 // refpoint is in. It may not be the exact center of the window if
 // the platform requires rounding the coordinate.
 static LayoutDeviceIntPoint
 GetWindowClientRectCenter(nsIWidget* aWidget)
 {
   NS_ENSURE_TRUE(aWidget, LayoutDeviceIntPoint(0, 0));
 
   LayoutDeviceIntRect rect = aWidget->GetClientBounds();
-  LayoutDeviceIntPoint point(rect.X() + rect.Width() / 2,
-                             rect.Y() + rect.Height() / 2);
+  LayoutDeviceIntPoint point(rect.x + rect.width / 2,
+                             rect.y + rect.height / 2);
   int32_t round = aWidget->RoundsWidgetCoordinatesTo();
   point.x = point.x / round * round;
   point.y = point.y / round * round;
   return point - aWidget->WidgetToScreenOffset();
 }
 
 void
 EventStateManager::GeneratePointerEnterExit(EventMessage aMessage,
--- a/dom/events/WheelHandlingHelper.cpp
+++ b/dom/events/WheelHandlingHelper.cpp
@@ -67,20 +67,20 @@ WheelHandlingUtils::CanScrollOn(nsIScrol
   NS_ASSERTION(aDirectionX || aDirectionY,
                "One of the delta values must be non-zero at least");
 
   nsPoint scrollPt = aScrollFrame->GetScrollPosition();
   nsRect scrollRange = aScrollFrame->GetScrollRange();
   uint32_t directions = aScrollFrame->GetPerceivedScrollingDirections();
 
   return (aDirectionX && (directions & nsIScrollableFrame::HORIZONTAL) &&
-          CanScrollInRange(scrollRange.X(), scrollPt.x,
+          CanScrollInRange(scrollRange.x, scrollPt.x,
                            scrollRange.XMost(), aDirectionX)) ||
          (aDirectionY && (directions & nsIScrollableFrame::VERTICAL) &&
-          CanScrollInRange(scrollRange.Y(), scrollPt.y,
+          CanScrollInRange(scrollRange.y, scrollPt.y,
                            scrollRange.YMost(), aDirectionY));
 }
 
 /******************************************************************/
 /* mozilla::WheelTransaction                                      */
 /******************************************************************/
 
 AutoWeakFrame WheelTransaction::sTargetFrame(nullptr);
--- a/dom/html/HTMLCanvasElement.cpp
+++ b/dom/html/HTMLCanvasElement.cpp
@@ -612,18 +612,18 @@ nsresult HTMLCanvasElement::GetEventTarg
     WidgetMouseEventBase* evt = (WidgetMouseEventBase*)aVisitor.mEvent;
     if (mCurrentContext) {
       nsIFrame *frame = GetPrimaryFrame();
       if (!frame)
         return NS_OK;
       nsPoint ptInRoot = nsLayoutUtils::GetEventCoordinatesRelativeTo(evt, frame);
       nsRect paddingRect = frame->GetContentRectRelativeToSelf();
       Point hitpoint;
-      hitpoint.x = (ptInRoot.x - paddingRect.X()) / AppUnitsPerCSSPixel();
-      hitpoint.y = (ptInRoot.y - paddingRect.Y()) / AppUnitsPerCSSPixel();
+      hitpoint.x = (ptInRoot.x - paddingRect.x) / AppUnitsPerCSSPixel();
+      hitpoint.y = (ptInRoot.y - paddingRect.y) / AppUnitsPerCSSPixel();
 
       evt->region = mCurrentContext->GetHitRegion(hitpoint);
       aVisitor.mCanHandle = true;
     }
   }
   return nsGenericHTMLElement::GetEventTargetParent(aVisitor);
 }
 
--- a/dom/html/ImageDocument.cpp
+++ b/dom/html/ImageDocument.cpp
@@ -430,18 +430,18 @@ ImageDocument::ScrollImageTo(int32_t aX,
 
   float ratio = GetRatio();
   // Don't try to scroll image if the document is not visible (mVisibleWidth or
   // mVisibleHeight is zero).
   if (ratio <= 0.0) {
     return;
   }
   nsRect portRect = sf->GetScrollPortRect();
-  sf->ScrollTo(nsPoint(nsPresContext::CSSPixelsToAppUnits(aX/ratio) - portRect.Width()/2,
-                       nsPresContext::CSSPixelsToAppUnits(aY/ratio) - portRect.Height()/2),
+  sf->ScrollTo(nsPoint(nsPresContext::CSSPixelsToAppUnits(aX/ratio) - portRect.width/2,
+                       nsPresContext::CSSPixelsToAppUnits(aY/ratio) - portRect.height/2),
                nsIScrollableFrame::INSTANT);
 }
 
 void
 ImageDocument::RestoreImage()
 {
   if (!mImageContent) {
     return;
@@ -733,18 +733,18 @@ ImageDocument::CheckOverflowing(bool cha
     nsIPresShell *shell = GetShell();
     if (!shell) {
       return NS_OK;
     }
 
     nsPresContext *context = shell->GetPresContext();
     nsRect visibleArea = context->GetVisibleArea();
 
-    mVisibleWidth = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.Width());
-    mVisibleHeight = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.Height());
+    mVisibleWidth = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.width);
+    mVisibleHeight = nsPresContext::AppUnitsToFloatCSSPixels(visibleArea.height);
   }
 
   bool imageWasOverflowing = ImageIsOverflowing();
   bool imageWasOverflowingVertically = mImageIsOverflowingVertically;
   mImageIsOverflowingHorizontally = mImageWidth > mVisibleWidth;
   mImageIsOverflowingVertically = mImageHeight > mVisibleHeight;
   bool windowBecameBigEnough = imageWasOverflowing && !ImageIsOverflowing();
   bool verticalOverflowChanged =
--- a/dom/html/MediaDocument.cpp
+++ b/dom/html/MediaDocument.cpp
@@ -258,17 +258,17 @@ nsresult
 MediaDocument::StartLayout()
 {
   mMayStartLayout = true;
   nsCOMPtr<nsIPresShell> shell = GetShell();
   // Don't mess with the presshell if someone has already handled
   // its initial reflow.
   if (shell && !shell->DidInitialize()) {
     nsRect visibleArea = shell->GetPresContext()->GetVisibleArea();
-    nsresult rv = shell->Initialize(visibleArea.Width(), visibleArea.Height());
+    nsresult rv = shell->Initialize(visibleArea.width, visibleArea.height);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return NS_OK;
 }
 
 void
 MediaDocument::GetFileName(nsAString& aResult, nsIChannel* aChannel)
--- a/dom/html/nsGenericHTMLElement.h
+++ b/dom/html/nsGenericHTMLElement.h
@@ -209,24 +209,24 @@ public:
     mozilla::CSSIntRect rcFrame;
     return GetOffsetRect(rcFrame);
   }
   int32_t OffsetTop()
   {
     mozilla::CSSIntRect rcFrame;
     GetOffsetRect(rcFrame);
 
-    return rcFrame.Y();
+    return rcFrame.y;
   }
   int32_t OffsetLeft()
   {
     mozilla::CSSIntRect rcFrame;
     GetOffsetRect(rcFrame);
 
-    return rcFrame.X();
+    return rcFrame.x;
   }
   int32_t OffsetWidth()
   {
     mozilla::CSSIntRect rcFrame;
     GetOffsetRect(rcFrame);
 
     return rcFrame.Width();
   }
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -899,26 +899,26 @@ TabChild::SetDimensions(uint32_t aFlags,
 }
 
 NS_IMETHODIMP
 TabChild::GetDimensions(uint32_t aFlags, int32_t* aX,
                              int32_t* aY, int32_t* aCx, int32_t* aCy)
 {
   ScreenIntRect rect = GetOuterRect();
   if (aX) {
-    *aX = rect.X();
+    *aX = rect.x;
   }
   if (aY) {
-    *aY = rect.Y();
+    *aY = rect.y;
   }
   if (aCx) {
-    *aCx = rect.Width();
+    *aCx = rect.width;
   }
   if (aCy) {
-    *aCy = rect.Height();
+    *aCy = rect.height;
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TabChild::SetFocus()
 {
@@ -1310,18 +1310,18 @@ TabChild::RecvUpdateDimensions(const Dim
 
     // Set the size on the document viewer before we update the widget and
     // trigger a reflow. Otherwise the MobileViewportManager reads the stale
     // size from the content viewer when it computes a new CSS viewport.
     nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(WebNavigation());
     baseWin->SetPositionAndSize(0, 0, screenSize.width, screenSize.height,
                                 nsIBaseWindow::eRepaint);
 
-    mPuppetWidget->Resize(screenRect.X() + mClientOffset.x + mChromeOffset.x,
-                          screenRect.Y() + mClientOffset.y + mChromeOffset.y,
+    mPuppetWidget->Resize(screenRect.x + mClientOffset.x + mChromeOffset.x,
+                          screenRect.y + mClientOffset.y + mChromeOffset.y,
                           screenSize.width, screenSize.height, true);
 
     return IPC_OK();
 }
 
 mozilla::ipc::IPCResult
 TabChild::RecvSizeModeChanged(const nsSizeMode& aSizeMode)
 {
@@ -3282,18 +3282,18 @@ TabChild::RecvUIResolutionChanged(const 
     if (presContext) {
       presContext->UIResolutionChangedSync();
     }
   }
 
   ScreenIntSize screenSize = GetInnerSize();
   if (mHasValidInnerSize && oldScreenSize != screenSize) {
     ScreenIntRect screenRect = GetOuterRect();
-    mPuppetWidget->Resize(screenRect.X() + mClientOffset.x + mChromeOffset.x,
-                          screenRect.Y() + mClientOffset.y + mChromeOffset.y,
+    mPuppetWidget->Resize(screenRect.x + mClientOffset.x + mChromeOffset.x,
+                          screenRect.y + mClientOffset.y + mChromeOffset.y,
                           screenSize.width, screenSize.height, true);
 
     nsCOMPtr<nsIBaseWindow> baseWin = do_QueryInterface(WebNavigation());
     baseWin->SetPositionAndSize(0, 0, screenSize.width, screenSize.height,
                                 nsIBaseWindow::eRepaint);
   }
 
   return IPC_OK();
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -3335,21 +3335,21 @@ TabParent::RecvInvokeDragSession(nsTArra
       do_GetService("@mozilla.org/widget/dragservice;1");
     if (dragService) {
       dragService->MaybeAddChildProcess(Manager()->AsContentParent());
     }
   }
 
   if (aVisualDnDData.type() == OptionalShmem::Tvoid_t ||
       !aVisualDnDData.get_Shmem().IsReadable() ||
-      aVisualDnDData.get_Shmem().Size<char>() < aDragRect.Height() * aStride) {
+      aVisualDnDData.get_Shmem().Size<char>() < aDragRect.height * aStride) {
     mDnDVisualization = nullptr;
   } else {
     mDnDVisualization =
-      gfx::CreateDataSourceSurfaceFromData(gfx::IntSize(aDragRect.Width(), aDragRect.Height()),
+        gfx::CreateDataSourceSurfaceFromData(gfx::IntSize(aDragRect.width, aDragRect.height),
                                              static_cast<gfx::SurfaceFormat>(aFormat),
                                              aVisualDnDData.get_Shmem().get<uint8_t>(),
                                              aStride);
   }
 
   mDragValid = true;
   mDragRect = aDragRect;
   mDragPrincipalURISpec = aPrincipalURISpec;
--- a/dom/media/MediaData.cpp
+++ b/dom/media/MediaData.cpp
@@ -118,32 +118,32 @@ static bool ValidateBufferAndPicture(con
   // in the decoder
   if (aBuffer.mPlanes[1].mWidth != aBuffer.mPlanes[2].mWidth ||
       aBuffer.mPlanes[1].mHeight != aBuffer.mPlanes[2].mHeight) {
     NS_ERROR("C planes with different sizes");
     return false;
   }
 
   // The following situations could be triggered by invalid input
-  if (aPicture.Width() <= 0 || aPicture.Height() <= 0) {
+  if (aPicture.width <= 0 || aPicture.height <= 0) {
     // In debug mode, makes the error more noticeable
     MOZ_ASSERT(false, "Empty picture rect");
     return false;
   }
   if (!ValidatePlane(aBuffer.mPlanes[0]) ||
       !ValidatePlane(aBuffer.mPlanes[1]) ||
       !ValidatePlane(aBuffer.mPlanes[2])) {
     NS_WARNING("Invalid plane size");
     return false;
   }
 
   // Ensure the picture size specified in the headers can be extracted out of
   // the frame we've been supplied without indexing out of bounds.
-  CheckedUint32 xLimit = aPicture.X() + CheckedUint32(aPicture.Width());
-  CheckedUint32 yLimit = aPicture.Y() + CheckedUint32(aPicture.Height());
+  CheckedUint32 xLimit = aPicture.x + CheckedUint32(aPicture.width);
+  CheckedUint32 yLimit = aPicture.y + CheckedUint32(aPicture.height);
   if (!xLimit.isValid() || xLimit.value() > aBuffer.mPlanes[0].mStride ||
       !yLimit.isValid() || yLimit.value() > aBuffer.mPlanes[0].mHeight) {
     // The specified picture dimensions can't be contained inside the video
     // frame, we'll stomp memory if we try to copy it. Fail.
     NS_WARNING("Overflowing picture rect");
     return false;
   }
   return true;
@@ -244,18 +244,18 @@ ConstructPlanarYCbCrData(const VideoInfo
   data.mYStride = Y.mStride;
   data.mYSkip = Y.mSkip;
   data.mCbChannel = Cb.mData + Cb.mOffset;
   data.mCrChannel = Cr.mData + Cr.mOffset;
   data.mCbCrSize = IntSize(Cb.mWidth, Cb.mHeight);
   data.mCbCrStride = Cb.mStride;
   data.mCbSkip = Cb.mSkip;
   data.mCrSkip = Cr.mSkip;
-  data.mPicX = aPicture.X();
-  data.mPicY = aPicture.Y();
+  data.mPicX = aPicture.x;
+  data.mPicY = aPicture.y;
   data.mPicSize = aPicture.Size();
   data.mStereoMode = aInfo.mStereoMode;
   data.mYUVColorSpace = aBuffer.mYUVColorSpace;
   data.mBitDepth = aBuffer.mBitDepth;
   return data;
 }
 
 /* static */ bool
--- a/dom/media/MediaInfo.h
+++ b/dom/media/MediaInfo.h
@@ -292,19 +292,21 @@ public:
     }
 
     gfx::IntRect imageRect = ImageRect();
     int64_t w = (aWidth * imageRect.Width()) / mImage.width;
     int64_t h = (aHeight * imageRect.Height()) / mImage.height;
     if (!w || !h) {
       return imageRect;
     }
-    imageRect.SetRect(imageRect.X() * aWidth / mImage.width,
-                      imageRect.X() * aHeight / mImage.height,
-                      w, h);
+
+    imageRect.x = (imageRect.x * aWidth) / mImage.width;
+    imageRect.y = (imageRect.y * aHeight) / mImage.height;
+    imageRect.SetWidth(w);
+    imageRect.SetHeight(h);
     return imageRect;
   }
 
   Rotation ToSupportedRotation(int32_t aDegree) const
   {
     switch (aDegree) {
       case 90:
         return kDegree_90;
--- a/dom/media/VideoUtils.cpp
+++ b/dom/media/VideoUtils.cpp
@@ -177,24 +177,24 @@ IsValidVideoRegion(const gfx::IntSize& a
                    const gfx::IntRect& aPicture,
                    const gfx::IntSize& aDisplay)
 {
   return
     aFrame.width <= PlanarYCbCrImage::MAX_DIMENSION &&
     aFrame.height <= PlanarYCbCrImage::MAX_DIMENSION &&
     aFrame.width * aFrame.height <= MAX_VIDEO_WIDTH * MAX_VIDEO_HEIGHT &&
     aFrame.width * aFrame.height != 0 &&
-    aPicture.Width() <= PlanarYCbCrImage::MAX_DIMENSION &&
-    aPicture.X() < PlanarYCbCrImage::MAX_DIMENSION &&
-    aPicture.XMost() < PlanarYCbCrImage::MAX_DIMENSION &&
-    aPicture.Height() <= PlanarYCbCrImage::MAX_DIMENSION &&
-    aPicture.Y() < PlanarYCbCrImage::MAX_DIMENSION &&
-    aPicture.YMost() < PlanarYCbCrImage::MAX_DIMENSION &&
-    aPicture.Width() * aPicture.Height() <= MAX_VIDEO_WIDTH * MAX_VIDEO_HEIGHT &&
-    !aPicture.IsZeroArea()&&
+    aPicture.width <= PlanarYCbCrImage::MAX_DIMENSION &&
+    aPicture.x < PlanarYCbCrImage::MAX_DIMENSION &&
+    aPicture.x + aPicture.width < PlanarYCbCrImage::MAX_DIMENSION &&
+    aPicture.height <= PlanarYCbCrImage::MAX_DIMENSION &&
+    aPicture.y < PlanarYCbCrImage::MAX_DIMENSION &&
+    aPicture.y + aPicture.height < PlanarYCbCrImage::MAX_DIMENSION &&
+    aPicture.width * aPicture.height <= MAX_VIDEO_WIDTH * MAX_VIDEO_HEIGHT &&
+    aPicture.width * aPicture.height != 0 &&
     aDisplay.width <= PlanarYCbCrImage::MAX_DIMENSION &&
     aDisplay.height <= PlanarYCbCrImage::MAX_DIMENSION &&
     aDisplay.width * aDisplay.height <= MAX_VIDEO_WIDTH * MAX_VIDEO_HEIGHT &&
     aDisplay.width * aDisplay.height != 0;
 }
 
 already_AddRefed<SharedThreadPool> GetMediaThreadPool(MediaThreadType aType)
 {
--- a/dom/media/platforms/wmf/WMFVideoMFTManager.cpp
+++ b/dom/media/platforms/wmf/WMFVideoMFTManager.cpp
@@ -646,18 +646,18 @@ WMFVideoMFTManager::InitInternal()
 {
   // The H264 SanityTest uses a 132x132 videos to determine if DXVA can be used.
   // so we want to use the software decoder for videos with lower resolutions.
   static const int MIN_H264_HW_WIDTH = 132;
   static const int MIN_H264_HW_HEIGHT = 132;
 
   mUseHwAccel = false; // default value; changed if D3D setup succeeds.
   bool useDxva = (mStreamType != H264 ||
-                  (mVideoInfo.ImageRect().Width() > MIN_H264_HW_WIDTH &&
-                   mVideoInfo.ImageRect().Height() > MIN_H264_HW_HEIGHT)) &&
+                  (mVideoInfo.ImageRect().width > MIN_H264_HW_WIDTH &&
+                   mVideoInfo.ImageRect().height > MIN_H264_HW_HEIGHT)) &&
                  InitializeDXVA();
 
   RefPtr<MFTDecoder> decoder;
 
   HRESULT hr;
   if (mStreamType == VP9 && useDxva && mCheckForAMDDecoder &&
       gfxPrefs::PDMWMFAMDVP9DecoderEnabled()) {
     if ((decoder = LoadAMDVP9Decoder())) {
@@ -740,33 +740,33 @@ WMFVideoMFTManager::InitInternal()
     // re-do initialization.
     return InitInternal();
   }
 
   LOG("Video Decoder initialized, Using DXVA: %s",
       (mUseHwAccel ? "Yes" : "No"));
 
   if (mDXVA2Manager) {
-    hr = mDXVA2Manager->ConfigureForSize(mVideoInfo.ImageRect().Width(),
-                                         mVideoInfo.ImageRect().Height());
+    hr = mDXVA2Manager->ConfigureForSize(mVideoInfo.ImageRect().width,
+                                         mVideoInfo.ImageRect().height);
     NS_ENSURE_TRUE(SUCCEEDED(hr),
                    MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
                                RESULT_DETAIL("Fail to configure image size for "
                                              "DXVA2Manager.")));
   } else {
     mYUVColorSpace = GetYUVColorSpace(outputType);
-    GetDefaultStride(outputType, mVideoInfo.ImageRect().Width(), &mVideoStride);
+    GetDefaultStride(outputType, mVideoInfo.ImageRect().width, &mVideoStride);
   }
   LOG("WMFVideoMFTManager frame geometry stride=%u picture=(%d, %d, %d, %d) "
       "display=(%d,%d)",
       mVideoStride,
-      mVideoInfo.ImageRect().X(),
-      mVideoInfo.ImageRect().Y(),
-      mVideoInfo.ImageRect().Width(),
-      mVideoInfo.ImageRect().Height(),
+      mVideoInfo.ImageRect().x,
+      mVideoInfo.ImageRect().y,
+      mVideoInfo.ImageRect().width,
+      mVideoInfo.ImageRect().height,
       mVideoInfo.mDisplay.width,
       mVideoInfo.mDisplay.height);
 
   if (!mUseHwAccel) {
     RefPtr<ID3D11Device> device =
       gfx::DeviceManagerDx::Get()->GetCompositorDevice();
     if (!device) {
       device = gfx::DeviceManagerDx::Get()->GetContentDevice();
@@ -802,31 +802,31 @@ WMFVideoMFTManager::SetDecoderMediaTypes
                             MFVideoInterlace_MixedInterlaceOrProgressive);
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   hr = inputType->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_Progressive);
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   hr = MFSetAttributeSize(inputType,
                           MF_MT_FRAME_SIZE,
-                          mVideoInfo.ImageRect().Width(),
-                          mVideoInfo.ImageRect().Height());
+                          mVideoInfo.ImageRect().width,
+                          mVideoInfo.ImageRect().height);
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   RefPtr<IMFMediaType> outputType;
   hr = wmf::MFCreateMediaType(getter_AddRefs(outputType));
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   hr = outputType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   hr = MFSetAttributeSize(outputType,
                           MF_MT_FRAME_SIZE,
-                          mVideoInfo.ImageRect().Width(),
-                          mVideoInfo.ImageRect().Height());
+                          mVideoInfo.ImageRect().width,
+                          mVideoInfo.ImageRect().height);
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   GUID outputSubType = mUseHwAccel ? MFVideoFormat_NV12 : MFVideoFormat_YV12;
   hr = outputType->SetGUID(MF_MT_SUBTYPE, outputSubType);
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   return mDecoder->SetMediaTypes(inputType, outputType);
 }
@@ -1131,17 +1131,17 @@ WMFVideoMFTManager::Output(int64_t aStre
       NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
       if (!mUseHwAccel) {
         // The stride may have changed, recheck for it.
         RefPtr<IMFMediaType> outputType;
         hr = mDecoder->GetOutputMediaType(outputType);
         NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
         mYUVColorSpace = GetYUVColorSpace(outputType);
-        hr = GetDefaultStride(outputType, mVideoInfo.ImageRect().Width(),
+        hr = GetDefaultStride(outputType, mVideoInfo.ImageRect().width,
                               &mVideoStride);
         NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
       }
       // Catch infinite loops, but some decoders perform at least 2 stream
       // changes on consecutive calls, so be permissive.
       // 100 is arbitrarily > 2.
       NS_ENSURE_TRUE(typeChangeCount < 100, MF_E_TRANSFORM_STREAM_CHANGE);
       // Loop back and try decoding again...
--- a/dom/media/webm/WebMDemuxer.cpp
+++ b/dom/media/webm/WebMDemuxer.cpp
@@ -344,20 +344,24 @@ WebMDemuxer::ReadMetadata()
       unsigned int cropH = params.crop_right + params.crop_left;
       unsigned int cropV = params.crop_bottom + params.crop_top;
       gfx::IntRect pictureRect(params.crop_left,
                                params.crop_top,
                                params.width - cropH,
                                params.height - cropV);
 
       // If the cropping data appears invalid then use the frame data
-      if (pictureRect.IsEmpty() ||
-          pictureRect.X() < 0 ||
-          pictureRect.Y() < 0) {
-        pictureRect.SetRect(0, 0, params.width, params.height);
+      if (pictureRect.width <= 0 ||
+          pictureRect.height <= 0 ||
+          pictureRect.x < 0 ||
+          pictureRect.y < 0) {
+        pictureRect.x = 0;
+        pictureRect.y = 0;
+        pictureRect.width = params.width;
+        pictureRect.height = params.height;
       }
 
       // Validate the container-reported frame and pictureRect sizes. This
       // ensures that our video frame creation code doesn't overflow.
       gfx::IntSize displaySize(params.display_width, params.display_height);
       gfx::IntSize frameSize(params.width, params.height);
       if (!IsValidVideoRegion(frameSize, pictureRect, displaySize)) {
         // Video track's frame sizes will overflow. Ignore the video track.
--- a/dom/plugins/ipc/PluginInstanceChild.cpp
+++ b/dom/plugins/ipc/PluginInstanceChild.cpp
@@ -2083,20 +2083,20 @@ PluginInstanceChild::ImmSetCandidateWind
         return FALSE;
     }
 
     CandidateWindowPosition position;
     position.mPoint.x = aForm->ptCurrentPos.x;
     position.mPoint.y = aForm->ptCurrentPos.y;
     position.mExcludeRect = !!(aForm->dwStyle & CFS_EXCLUDE);
     if (position.mExcludeRect) {
-      position.mRect.SetRect(aForm->rcArea.left,
-                             aForm->rcArea.top,
-                             aForm->rcArea.right - aForm->rcArea.left,
-                             aForm->rcArea.bottom - aForm->rcArea.top);
+      position.mRect.x = aForm->rcArea.left;
+      position.mRect.y = aForm->rcArea.top;
+      position.mRect.width = aForm->rcArea.right - aForm->rcArea.left;
+      position.mRect.height = aForm->rcArea.bottom - aForm->rcArea.top;
     }
 
     sCurrentPluginInstance->SendSetCandidateWindow(position);
     return TRUE;
 }
 
 // static
 BOOL
@@ -3347,37 +3347,37 @@ PluginInstanceChild::PaintRectToPlatform
         NS_ASSERTION(aSurface->GetType() == gfxSurfaceType::Xlib,
                      "Non supported platform surface type");
 
         NPEvent pluginEvent;
         XGraphicsExposeEvent& exposeEvent = pluginEvent.xgraphicsexpose;
         exposeEvent.type = GraphicsExpose;
         exposeEvent.display = mWsInfo.display;
         exposeEvent.drawable = static_cast<gfxXlibSurface*>(aSurface)->XDrawable();
-        exposeEvent.x = aRect.X();
-        exposeEvent.y = aRect.Y();
-        exposeEvent.width = aRect.Width();
-        exposeEvent.height = aRect.Height();
+        exposeEvent.x = aRect.x;
+        exposeEvent.y = aRect.y;
+        exposeEvent.width = aRect.width;
+        exposeEvent.height = aRect.height;
         exposeEvent.count = 0;
         // information not set:
         exposeEvent.serial = 0;
         exposeEvent.send_event = False;
         exposeEvent.major_code = 0;
         exposeEvent.minor_code = 0;
         mPluginIface->event(&mData, reinterpret_cast<void*>(&exposeEvent));
     }
 #elif defined(XP_WIN)
     NS_ASSERTION(SharedDIBSurface::IsSharedDIBSurface(aSurface),
                  "Expected (SharedDIB) image surface.");
 
     // This rect is in the window coordinate space. aRect is in the plugin
     // coordinate space.
     RECT rect = {
-        mWindow.x + aRect.X(),
-        mWindow.y + aRect.Y(),
+        mWindow.x + aRect.x,
+        mWindow.y + aRect.y,
         mWindow.x + aRect.XMost(),
         mWindow.y + aRect.YMost()
     };
     NPEvent paintEvent = {
         WM_PAINT,
         uintptr_t(mWindow.window),
         intptr_t(&rect)
     };
@@ -3410,18 +3410,18 @@ PluginInstanceChild::PaintRectToSurface(
     if (mHelperSurface) {
         // On X11 we can paint to non Xlib surface only with HelperSurface
         renderSurface = mHelperSurface;
     }
 #endif
 
     if (mIsTransparent && !CanPaintOnBackground()) {
         RefPtr<DrawTarget> dt = CreateDrawTargetForSurface(renderSurface);
-        gfx::Rect rect(plPaintRect.X(), plPaintRect.Y(),
-                       plPaintRect.Width(), plPaintRect.Height());
+        gfx::Rect rect(plPaintRect.x, plPaintRect.y,
+                       plPaintRect.width, plPaintRect.height);
         // Moz2D treats OP_SOURCE operations as unbounded, so we need to
         // clip to the rect that we want to fill:
         dt->PushClipRect(rect);
         dt->FillRect(rect, ColorPattern(aColor), // aColor is already a device color
                      DrawOptions(1.f, CompositionOp::OP_SOURCE));
         dt->PopClip();
         dt->Flush();
     }
@@ -3483,18 +3483,18 @@ PluginInstanceChild::PaintRectWithAlphaE
             rect =
                 gfxAlphaRecovery::AlignRectForSubimageRecovery(aRect,
                                                                surfaceAsImage);
         }
     }
 
     RefPtr<gfxImageSurface> whiteImage;
     RefPtr<gfxImageSurface> blackImage;
-    gfxRect targetRect(rect.X(), rect.Y(), rect.Width(), rect.Height());
-    IntSize targetSize(rect.Width(), rect.Height());
+    gfxRect targetRect(rect.x, rect.y, rect.width, rect.height);
+    IntSize targetSize(rect.width, rect.height);
     gfxPoint deviceOffset = -targetRect.TopLeft();
 
     // We always use a temporary "white image"
     whiteImage = new gfxImageSurface(targetSize, SurfaceFormat::X8R8G8B8_UINT32);
     if (whiteImage->CairoStatus()) {
         return;
     }
 
@@ -3552,17 +3552,17 @@ PluginInstanceChild::PaintRectWithAlphaE
 
     // If we had to use a temporary black surface, copy the pixels
     // with alpha back to the target
     if (!useSurfaceSubimageForBlack) {
         RefPtr<DrawTarget> dt = CreateDrawTargetForSurface(aSurface);
         RefPtr<SourceSurface> surface =
             gfxPlatform::GetSourceSurfaceForSurface(dt, blackImage);
         dt->CopySurface(surface,
-                        IntRect(0, 0, rect.Width(), rect.Height()),
+                        IntRect(0, 0, rect.width, rect.height),
                         rect.TopLeft());
     }
 }
 
 bool
 PluginInstanceChild::CanPaintOnBackground()
 {
     return (mBackground &&
@@ -3682,17 +3682,17 @@ PluginInstanceChild::ShowPluginFrame()
         rect.SetRect(0, 0, mWindow.width, mWindow.height);
     }
 
     bool haveTransparentPixels =
         gfxContentType::COLOR_ALPHA == mCurrentSurface->GetContentType();
     PLUGIN_LOG_DEBUG(
         ("[InstanceChild][%p] Painting%s <x=%d,y=%d, w=%d,h=%d> on surface <w=%d,h=%d>",
          this, haveTransparentPixels ? " with alpha" : "",
-         rect.X(), rect.Y(), rect.Width(), rect.Height(),
+         rect.x, rect.y, rect.width, rect.height,
          mCurrentSurface->GetSize().width, mCurrentSurface->GetSize().height));
 
     if (CanPaintOnBackground()) {
         PLUGIN_LOG_DEBUG(("  (on background)"));
         // Source the background pixels ...
         {
             RefPtr<gfxASurface> surface =
                 mHelperSurface ? mHelperSurface : mCurrentSurface;
@@ -3740,17 +3740,17 @@ PluginInstanceChild::ShowPluginFrame()
         // browser.  We may have painted a transparent plugin using
         // the opaque-plugin path, which can result in wrong pixels.
         // We also don't want to pay the expense of forwarding the
         // surface for plugins that might really be invisible.
         mAccumulatedInvalidRect.SetRect(0, 0, mWindow.width, mWindow.height);
         return true;
     }
 
-    NPRect r = { (uint16_t)rect.Y(), (uint16_t)rect.X(),
+    NPRect r = { (uint16_t)rect.y, (uint16_t)rect.x,
                  (uint16_t)rect.YMost(), (uint16_t)rect.XMost() };
     SurfaceDescriptor currSurf;
 #ifdef MOZ_X11
     if (mCurrentSurface->GetType() == gfxSurfaceType::Xlib) {
         gfxXlibSurface *xsurf = static_cast<gfxXlibSurface*>(mCurrentSurface.get());
         currSurf = SurfaceDescriptorX11(xsurf);
         // Need to sync all pending x-paint requests
         // before giving drawable to another process
@@ -3813,18 +3813,18 @@ PluginInstanceChild::ReadbackDifferenceR
     if (mCurrentSurface->GetContentType() != mBackSurface->GetContentType())
         return false;
 
     if (mSurfaceDifferenceRect.IsEmpty())
         return true;
 
     PLUGIN_LOG_DEBUG(
         ("[InstanceChild][%p] Reading back part of <x=%d,y=%d, w=%d,h=%d>",
-         this, mSurfaceDifferenceRect.X(), mSurfaceDifferenceRect.Y(),
-         mSurfaceDifferenceRect.Width(), mSurfaceDifferenceRect.Height()));
+         this, mSurfaceDifferenceRect.x, mSurfaceDifferenceRect.y,
+         mSurfaceDifferenceRect.width, mSurfaceDifferenceRect.height));
 
     // Read back previous content
     RefPtr<DrawTarget> dt = CreateDrawTargetForSurface(mCurrentSurface);
     RefPtr<SourceSurface> source =
         gfxPlatform::GetSourceSurfaceForSurface(dt, mBackSurface);
     // Subtract from mSurfaceDifferenceRect area which is overlapping with rect
     nsIntRegion result;
     result.Sub(mSurfaceDifferenceRect, nsIntRegion(rect));
--- a/dom/plugins/ipc/PluginInstanceParent.cpp
+++ b/dom/plugins/ipc/PluginInstanceParent.cpp
@@ -778,17 +778,17 @@ PluginInstanceParent::SetCurrentImage(Im
     holder.mFrameID = ++mFrameID;
 
     AutoTArray<ImageContainer::NonOwningImage,1> imageList;
     imageList.AppendElement(holder);
     mImageContainer->SetCurrentImages(imageList);
 
     // Invalidate our area in the page so the image gets flushed.
     gfx::IntRect rect = aImage->GetPictureRect();
-    NPRect nprect = {uint16_t(rect.X()), uint16_t(rect.Y()), uint16_t(rect.Width()), uint16_t(rect.Height())};
+    NPRect nprect = {uint16_t(rect.x), uint16_t(rect.y), uint16_t(rect.width), uint16_t(rect.height)};
     RecvNPN_InvalidateRect(nprect);
 
     RecordDrawingModel();
 }
 
 mozilla::ipc::IPCResult
 PluginInstanceParent::RecvShowDirectDXGISurface(const WindowsHandle& handle,
                                                  const gfx::IntRect& dirty)
@@ -1106,17 +1106,17 @@ PluginInstanceParent::SetBackgroundUnkno
 }
 
 nsresult
 PluginInstanceParent::BeginUpdateBackground(const nsIntRect& aRect,
                                             DrawTarget** aDrawTarget)
 {
     PLUGIN_LOG_DEBUG(
         ("[InstanceParent][%p] BeginUpdateBackground for <x=%d,y=%d, w=%d,h=%d>",
-         this, aRect.X(), aRect.Y(), aRect.Width(), aRect.Height()));
+         this, aRect.x, aRect.y, aRect.width, aRect.height));
 
     if (!mBackground) {
         // XXX if we failed to create a background surface on one
         // update, there's no guarantee that later updates will be for
         // the entire background area until successful.  We might want
         // to fix that eventually.
         MOZ_ASSERT(aRect.TopLeft() == nsIntPoint(0, 0),
                    "Expecting rect for whole frame");
@@ -1139,17 +1139,17 @@ PluginInstanceParent::BeginUpdateBackgro
     return NS_OK;
 }
 
 nsresult
 PluginInstanceParent::EndUpdateBackground(const nsIntRect& aRect)
 {
     PLUGIN_LOG_DEBUG(
         ("[InstanceParent][%p] EndUpdateBackground for <x=%d,y=%d, w=%d,h=%d>",
-         this, aRect.X(), aRect.Y(), aRect.Width(), aRect.Height()));
+         this, aRect.x, aRect.y, aRect.width, aRect.height));
 
 #ifdef MOZ_X11
     // Have to XSync here to avoid the plugin trying to draw with this
     // surface racing with its creation in the X server.  We also want
     // to avoid the plugin drawing onto stale pixels, then handing us
     // back a front surface from those pixels that we might
     // recomposite for "a while" until the next update.  This XSync
     // still doesn't guarantee that the plugin draws onto a consistent
--- a/dom/svg/SVGFEImageElement.cpp
+++ b/dom/svg/SVGFEImageElement.cpp
@@ -243,21 +243,21 @@ SVGFEImageElement::GetPrimitiveDescripti
     return FilterPrimitiveDescription(PrimitiveType::Empty);
   }
 
   IntSize nativeSize;
   imageContainer->GetWidth(&nativeSize.width);
   imageContainer->GetHeight(&nativeSize.height);
 
   Matrix viewBoxTM =
-    SVGContentUtils::GetViewBoxTransform(aFilterSubregion.Width(), aFilterSubregion.Height(),
+    SVGContentUtils::GetViewBoxTransform(aFilterSubregion.width, aFilterSubregion.height,
                                          0, 0, nativeSize.width, nativeSize.height,
                                          mPreserveAspectRatio);
   Matrix TM = viewBoxTM;
-  TM.PostTranslate(aFilterSubregion.X(), aFilterSubregion.Y());
+  TM.PostTranslate(aFilterSubregion.x, aFilterSubregion.y);
 
   SamplingFilter samplingFilter = nsLayoutUtils::GetSamplingFilterForFrame(frame);
 
   FilterPrimitiveDescription descr(PrimitiveType::Image);
   descr.Attributes().Set(eImageFilter, (uint32_t)samplingFilter);
   descr.Attributes().Set(eImageTransform, TM);
 
   // Append the image to aInputImages and store its index in the description.
--- a/dom/svg/SVGFETurbulenceElement.cpp
+++ b/dom/svg/SVGFETurbulenceElement.cpp
@@ -151,18 +151,18 @@ SVGFETurbulenceElement::GetPrimitiveDesc
   // If a frequency in user space units is zero, then it will also be zero in
   // filter space. During the conversion we use a dummy period length of 1
   // for those frequencies but then ignore the converted length and use 0
   // for the converted frequency. This avoids division by zero.
   gfxRect firstPeriodInUserSpace(0, 0,
                                  fX == 0 ? 1 : (1 / fX),
                                  fY == 0 ? 1 : (1 / fY));
   gfxRect firstPeriodInFilterSpace = aInstance->UserSpaceToFilterSpace(firstPeriodInUserSpace);
-  Size frequencyInFilterSpace(fX == 0 ? 0 : (1 / firstPeriodInFilterSpace.Width()),
-                              fY == 0 ? 0 : (1 / firstPeriodInFilterSpace.Height()));
+  Size frequencyInFilterSpace(fX == 0 ? 0 : (1 / firstPeriodInFilterSpace.width),
+                              fY == 0 ? 0 : (1 / firstPeriodInFilterSpace.height));
   gfxPoint offset = firstPeriodInFilterSpace.TopLeft();
 
   FilterPrimitiveDescription descr(PrimitiveType::Turbulence);
   descr.Attributes().Set(eTurbulenceOffset, IntPoint::Truncate(offset.x, offset.y));
   descr.Attributes().Set(eTurbulenceBaseFrequency, frequencyInFilterSpace);
   descr.Attributes().Set(eTurbulenceSeed, seed);
   descr.Attributes().Set(eTurbulenceNumOctaves, octaves);
   descr.Attributes().Set(eTurbulenceStitchable, stitch == SVG_STITCHTYPE_STITCH);
--- a/dom/svg/SVGImageElement.cpp
+++ b/dom/svg/SVGImageElement.cpp
@@ -245,20 +245,20 @@ SVGImageElement::IsAttributeMapped(const
 /* For the purposes of the update/invalidation logic pretend to
    be a rectangle. */
 bool
 SVGImageElement::GetGeometryBounds(Rect* aBounds,
                                    const StrokeOptions& aStrokeOptions,
                                    const Matrix& aToBoundsSpace,
                                    const Matrix* aToNonScalingStrokeSpace)
 {
-  float x, y, width, height;
-  GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
+  Rect rect;
+  GetAnimatedLengthValues(&rect.x, &rect.y, &rect.width,
+                          &rect.height, nullptr);
 
-  Rect rect(x, y, width, height);
   if (rect.IsEmpty()) {
     // Rendering of the element disabled
     rect.SetEmpty(); // Make sure width/height are zero and not negative
   }
 
   *aBounds = aToBoundsSpace.TransformBounds(rect);
   return true;
 }
--- a/dom/svg/SVGRect.cpp
+++ b/dom/svg/SVGRect.cpp
@@ -47,12 +47,12 @@ NS_NewSVGRect(nsIContent* aParent, float
     new mozilla::dom::SVGRect(aParent, aX, aY, aWidth, aHeight);
 
   return rect.forget();
 }
 
 already_AddRefed<mozilla::dom::SVGRect>
 NS_NewSVGRect(nsIContent* aParent, const Rect& aRect)
 {
-  return NS_NewSVGRect(aParent, aRect.X(), aRect.Y(),
-                       aRect.Width(), aRect.Height());
+  return NS_NewSVGRect(aParent, aRect.x, aRect.y,
+                       aRect.width, aRect.height);
 }
 
--- a/dom/svg/SVGRectElement.cpp
+++ b/dom/svg/SVGRectElement.cpp
@@ -113,20 +113,21 @@ SVGRectElement::GetLengthInfo()
 // SVGGeometryElement methods
 
 bool
 SVGRectElement::GetGeometryBounds(Rect* aBounds,
                                   const StrokeOptions& aStrokeOptions,
                                   const Matrix& aToBoundsSpace,
                                   const Matrix* aToNonScalingStrokeSpace)
 {
-  Float x, y, width, height, rx, ry;
-  GetAnimatedLengthValues(&x, &y, &width, &height, &rx, &ry, nullptr);
+  Rect rect;
+  Float rx, ry;
+  GetAnimatedLengthValues(&rect.x, &rect.y, &rect.width,
+                          &rect.height, &rx, &ry, nullptr);
 
-  Rect rect(x, y, width, height);
   if (rect.IsEmpty()) {
     // Rendering of the element disabled
     rect.SetEmpty(); // Make sure width/height are zero and not negative
     // We still want the x/y position from 'rect'
     *aBounds = aToBoundsSpace.TransformBounds(rect);
     return true;
   }
 
--- a/dom/xul/XULDocument.cpp
+++ b/dom/xul/XULDocument.cpp
@@ -1573,17 +1573,17 @@ XULDocument::StartLayout(void)
 
         nsCOMPtr<nsIDocShell> docShell = cx->GetDocShell();
         NS_ASSERTION(docShell != nullptr, "container is not a docshell");
         if (! docShell)
             return NS_ERROR_UNEXPECTED;
 
         nsresult rv = NS_OK;
         nsRect r = cx->GetVisibleArea();
-        rv = shell->Initialize(r.Width(), r.Height());
+        rv = shell->Initialize(r.width, r.height);
         NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
 }
 
 /* static */
 bool