Backed out changeset 71fe4233208a (bug 1076163)

2014-11-13 11:47:35 +01:00 · 2014-11-13 11:47:35 +01:00 · c247fdb775
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@ -250,7 +250,7 @@ TabChildBase::InitializeRootMetrics()
    mLastRootMetrics.GetZoom() / mLastRootMetrics.mDevPixelsPerCSSPixel * ScreenToLayerScale(1);
  // This is the root layer, so the cumulative resolution is the same
  // as the resolution.
-  mLastRootMetrics.mPresShellResolution = mLastRootMetrics.mCumulativeResolution / LayoutDeviceToParentLayerScale(1);
+  mLastRootMetrics.mResolution = mLastRootMetrics.mCumulativeResolution / LayoutDeviceToParentLayerScale(1);
  mLastRootMetrics.SetScrollOffset(CSSPoint(0, 0));

  TABC_LOG("After InitializeRootMetrics, mLastRootMetrics is %s\n",
@ -417,8 +417,8 @@ TabChildBase::HandlePossibleViewportChange(const ScreenIntSize& aOldScreenSize)
  metrics.mCumulativeResolution = metrics.GetZoom() / metrics.mDevPixelsPerCSSPixel * ScreenToLayerScale(1);
  // This is the root layer, so the cumulative resolution is the same
  // as the resolution.
-  metrics.mPresShellResolution = metrics.mCumulativeResolution / LayoutDeviceToParentLayerScale(1);
-  utils->SetResolution(metrics.mPresShellResolution.scale, metrics.mPresShellResolution.scale);
+  metrics.mResolution = metrics.mCumulativeResolution / LayoutDeviceToParentLayerScale(1);
+  utils->SetResolution(metrics.mResolution.scale, metrics.mResolution.scale);

  CSSSize scrollPort = metrics.CalculateCompositedSizeInCssPixels();
  utils->SetScrollPositionClampingScrollPortSize(scrollPort.width, scrollPort.height);
@ -907,8 +907,8 @@ TabChild::Observe(nsISupports *aSubject,
        // until we we get an inner size.
        if (HasValidInnerSize()) {
          InitializeRootMetrics();
-          utils->SetResolution(mLastRootMetrics.mPresShellResolution.scale,
-                               mLastRootMetrics.mPresShellResolution.scale);
+          utils->SetResolution(mLastRootMetrics.mResolution.scale,
+                               mLastRootMetrics.mResolution.scale);
          HandlePossibleViewportChange(mInnerSize);
        }
      }
--- a/gfx/ipc/GfxMessageUtils.h
+++ b/gfx/ipc/GfxMessageUtils.h
@ -741,7 +741,7 @@ struct ParamTraits<mozilla::layers::FrameMetrics>
    WriteParam(aMsg, aParam.mRootCompositionSize);
    WriteParam(aMsg, aParam.mScrollId);
    WriteParam(aMsg, aParam.mScrollParentId);
-    WriteParam(aMsg, aParam.mPresShellResolution);
+    WriteParam(aMsg, aParam.mResolution);
    WriteParam(aMsg, aParam.mCumulativeResolution);
    WriteParam(aMsg, aParam.mZoom);
    WriteParam(aMsg, aParam.mDevPixelsPerCSSPixel);
@ -783,7 +783,7 @@ struct ParamTraits<mozilla::layers::FrameMetrics>
            ReadParam(aMsg, aIter, &aResult->mRootCompositionSize) &&
            ReadParam(aMsg, aIter, &aResult->mScrollId) &&
            ReadParam(aMsg, aIter, &aResult->mScrollParentId) &&
-            ReadParam(aMsg, aIter, &aResult->mPresShellResolution) &&
+            ReadParam(aMsg, aIter, &aResult->mResolution) &&
            ReadParam(aMsg, aIter, &aResult->mCumulativeResolution) &&
            ReadParam(aMsg, aIter, &aResult->mZoom) &&
            ReadParam(aMsg, aIter, &aResult->mDevPixelsPerCSSPixel) &&
--- a/gfx/layers/FrameMetrics.h
+++ b/gfx/layers/FrameMetrics.h
@ -76,7 +76,7 @@ public:
    , mDisplayPort(0, 0, 0, 0)
    , mCriticalDisplayPort(0, 0, 0, 0)
    , mScrollableRect(0, 0, 0, 0)
-    , mPresShellResolution(1)
+    , mResolution(1)
    , mCumulativeResolution(1)
    , mTransformScale(1)
    , mDevPixelsPerCSSPixel(1)
@ -114,7 +114,7 @@ public:
           mCriticalDisplayPort.IsEqualEdges(aOther.mCriticalDisplayPort) &&
           mViewport.IsEqualEdges(aOther.mViewport) &&
           mScrollableRect.IsEqualEdges(aOther.mScrollableRect) &&
-           mPresShellResolution == aOther.mPresShellResolution &&
+           mResolution == aOther.mResolution &&
           mCumulativeResolution == aOther.mCumulativeResolution &&
           mDevPixelsPerCSSPixel == aOther.mDevPixelsPerCSSPixel &&
           mMayHaveTouchListeners == aOther.mMayHaveTouchListeners &&
@ -171,10 +171,14 @@ public:
    return mCumulativeResolution * mDevPixelsPerCSSPixel;
  }

-  // Get the amount by which this frame has been zoomed since the last repaint.
-  LayerToScreenScale GetAsyncZoom() const
+  LayerPoint GetScrollOffsetInLayerPixels() const
  {
-    return mZoom / LayersPixelsPerCSSPixel();
+    return GetScrollOffset() * LayersPixelsPerCSSPixel();
+  }
+
+  LayoutDeviceToParentLayerScale GetParentResolution() const
+  {
+    return mCumulativeResolution / mResolution;
  }

  // Ensure the scrollableRect is at least as big as the compositionBounds
@ -339,17 +343,14 @@ public:
  // The following metrics are dimensionless.
  //

-  // The pres-shell resolution that has been induced on the document containing
-  // this scroll frame as a result of zooming this scroll frame (whether via
-  // user action, or choosing an initial zoom level on page load). This can
-  // only be different from 1.0 for frames that are zoomable, which currently
-  // is just the root content document's root scroll frame (mIsRoot = true).
-  ParentLayerToLayerScale mPresShellResolution;
+  // The incremental resolution that the current frame has been painted at
+  // relative to the parent frame's resolution. This information is provided
+  // by Gecko at layout/paint time.
+  ParentLayerToLayerScale mResolution;

  // The cumulative resolution that the current frame has been painted at.
-  // This is the product of the pres-shell resolutions of the document
-  // containing this scroll frame and its ancestors, and any css-driven
-  // resolution. This information is provided by Gecko at layout/paint time.
+  // This is the product of our mResolution and the mResolutions of our parent frames.
+  // This information is provided by Gecko at layout/paint time.
  LayoutDeviceToLayerScale mCumulativeResolution;

  // TODO(botond): This is now always 1 and should be removed (see bug 1055741).
--- a/gfx/layers/LayersLogging.cpp
+++ b/gfx/layers/LayersLogging.cpp
@ -159,7 +159,7 @@ AppendToString(std::stringstream& aStream, const FrameMetrics& m,
    AppendToString(aStream, m.GetRootCompositionSize(), " rcs=");
    AppendToString(aStream, m.GetViewport(), " v=");
    aStream << nsPrintfCString(" z=(ld=%.3f r=%.3f cr=%.3f z=%.3f ts=%.3f)",
-            m.mDevPixelsPerCSSPixel.scale, m.mPresShellResolution.scale,
+            m.mDevPixelsPerCSSPixel.scale, m.mResolution.scale,
            m.mCumulativeResolution.scale, m.GetZoom().scale,
            m.mTransformScale.scale).get();
    aStream << nsPrintfCString(" u=(%d %d %lu)",
--- a/gfx/layers/apz/src/APZCTreeManager.cpp
+++ b/gfx/layers/apz/src/APZCTreeManager.cpp
@ -197,17 +197,12 @@ ComputeTouchSensitiveRegion(GeckoContentController* aController,
  ParentLayerRect visible(aMetrics.mCompositionBounds);
  CSSRect touchSensitiveRegion;
  if (aController->GetTouchSensitiveRegion(&touchSensitiveRegion)) {
-    // Here we assume 'touchSensitiveRegion' is in the CSS pixels of the
-    // parent frame. To convert it to ParentLayer pixels, we therefore need
-    // the cumulative resolution of the parent frame. We approximate this as
-    // the quotient of our cumulative resolution and our pres shell resolution;
-    // this approximation may not be accurate in the presence of a css-driven
-    // resolution.
-    LayoutDeviceToParentLayerScale parentCumulativeResolution =
-        aMetrics.mCumulativeResolution / aMetrics.mPresShellResolution;
+    // Note: we assume here that touchSensitiveRegion is in the CSS pixels
+    // of our parent layer, which makes this coordinate conversion
+    // correct.
    visible = visible.Intersect(touchSensitiveRegion
                                * aMetrics.mDevPixelsPerCSSPixel
-                                * parentCumulativeResolution);
+                                * aMetrics.GetParentResolution());
  }

  // Not sure what rounding option is the most correct here, but if we ever
--- a/gfx/layers/apz/src/AsyncPanZoomController.cpp
+++ b/gfx/layers/apz/src/AsyncPanZoomController.cpp
@ -2588,8 +2588,9 @@ ViewTransform AsyncPanZoomController::GetCurrentAsyncTransform() const {
    }
  }

-  ParentLayerToScreenScale scale = mFrameMetrics.mPresShellResolution  // non-transient portion
-                                 * mFrameMetrics.GetAsyncZoom();       // transient portion
+  ParentLayerToScreenScale scale = mFrameMetrics.GetZoom()
+        / mLastContentPaintMetrics.mDevPixelsPerCSSPixel
+        / mFrameMetrics.GetParentResolution();
  ScreenPoint translation = (currentScrollOffset - lastPaintScrollOffset)
                          * mFrameMetrics.GetZoom();

@ -2598,27 +2599,24 @@ ViewTransform AsyncPanZoomController::GetCurrentAsyncTransform() const {

 Matrix4x4 AsyncPanZoomController::GetNontransientAsyncTransform() const {
  ReentrantMonitorAutoEnter lock(mMonitor);
-  return Matrix4x4::Scaling(mLastContentPaintMetrics.mPresShellResolution.scale,
-                            mLastContentPaintMetrics.mPresShellResolution.scale,
+  return Matrix4x4::Scaling(mLastContentPaintMetrics.mResolution.scale,
+                            mLastContentPaintMetrics.mResolution.scale,
                            1.0f);
 }

 Matrix4x4 AsyncPanZoomController::GetTransformToLastDispatchedPaint() const {
  ReentrantMonitorAutoEnter lock(mMonitor);

+  // Technically we should be taking the scroll delta in the coordinate space
+  // of transformed layer pixels (i.e. this layer's LayerPixels, with the layer
+  // transform applied). However in the absence of actual CSS transforms, we
+  // can use the parent-layer space instead.
+  // When we fix bug 993525 and properly support CSS transforms we might have
+  // to revisit this.
  ParentLayerPoint scrollChange =
    (mLastContentPaintMetrics.GetScrollOffset() - mLastDispatchedPaintMetrics.GetScrollOffset())
    * mLastContentPaintMetrics.mDevPixelsPerCSSPixel
-    * mLastContentPaintMetrics.mCumulativeResolution
-      // This transform ("LD" in the terminology of the comment above
-      // GetScreenToApzcTransform() in APZCTreeManager.h) is applied in a
-      // coordinate space that includes the APZC's CSS transform ("LC").
-      // This CSS transform is the identity unless this APZC sets a pres-shell
-      // resolution, in which case the transform has a post-scale that cancels
-      // out the pres-shell resolution. We simulate applying the "LC" transform
-      // by dividing by the pres-shell resolution. This will go away once
-      // bug 1076192 is fixed.
-    / mLastContentPaintMetrics.mPresShellResolution;
+    * mLastContentPaintMetrics.GetParentResolution();

  float zoomChange = mLastContentPaintMetrics.GetZoom().scale / mLastDispatchedPaintMetrics.GetZoom().scale;

@ -2712,18 +2710,9 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri

    if (FuzzyEqualsAdditive(mFrameMetrics.mCompositionBounds.width, aLayerMetrics.mCompositionBounds.width) &&
        mFrameMetrics.mDevPixelsPerCSSPixel == aLayerMetrics.mDevPixelsPerCSSPixel) {
-      // Any change to the pres shell resolution was requested by APZ and is
-      // already included in our zoom; however, other components of the
-      // cumulative resolution (a parent document's pres-shell resolution, or
-      // the css-driven resolution) may have changed, and we need to update
-      // our zoom to reflect that. Note that we can't just take
-      // aLayerMetrics.mZoom because the APZ may have additional async zoom
-      // since the repaint request.
-      float totalResolutionChange = aLayerMetrics.mCumulativeResolution.scale
-                                  / mFrameMetrics.mCumulativeResolution.scale;
-      float presShellResolutionChange = aLayerMetrics.mPresShellResolution.scale
-                                      / mFrameMetrics.mPresShellResolution.scale;
-      mFrameMetrics.ZoomBy(totalResolutionChange / presShellResolutionChange);
+      float parentResolutionChange = aLayerMetrics.GetParentResolution().scale
+                                   / mFrameMetrics.GetParentResolution().scale;
+      mFrameMetrics.ZoomBy(parentResolutionChange);
    } else {
      // Take the new zoom as either device scale or composition width or both
      // got changed (e.g. due to orientation change).
@ -2736,7 +2725,7 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri
    }
    mFrameMetrics.mCompositionBounds = aLayerMetrics.mCompositionBounds;
    mFrameMetrics.SetRootCompositionSize(aLayerMetrics.GetRootCompositionSize());
-    mFrameMetrics.mPresShellResolution = aLayerMetrics.mPresShellResolution;
+    mFrameMetrics.mResolution = aLayerMetrics.mResolution;
    mFrameMetrics.mCumulativeResolution = aLayerMetrics.mCumulativeResolution;
    mFrameMetrics.SetHasScrollgrab(aLayerMetrics.GetHasScrollgrab());

--- a/gfx/layers/apz/util/APZCCallbackHelper.cpp
+++ b/gfx/layers/apz/util/APZCCallbackHelper.cpp
@ -142,12 +142,19 @@ APZCCallbackHelper::UpdateRootFrame(nsIDOMWindowUtils* aUtils,

    aMetrics.SetScrollOffset(actualScrollOffset);

-    // The pres shell resolution is updated by the the async zoom since the
-    // last paint. The ScreenToLayerScale(1.0f) reflects this async zoom being
-    // turned into a "sync" zoom during the repaint.
-    ParentLayerToLayerScale presShellResolution = aMetrics.mPresShellResolution
-                                                * aMetrics.GetAsyncZoom()
-                                                * ScreenToLayerScale(1.0f);
+    // The mZoom variable on the frame metrics stores the CSS-to-screen scale for this
+    // frame. This scale includes all of the (cumulative) resolutions set on the presShells
+    // from the root down to this frame. However, when setting the resolution, we only
+    // want the piece of the resolution that corresponds to this presShell, rather than
+    // all of the cumulative stuff, so we need to divide out the parent resolutions.
+    // Finally, we multiply by a ScreenToLayerScale of 1.0f because the goal here is to
+    // take the async zoom calculated by the APZC and tell gecko about it (turning it into
+    // a "sync" zoom) which will update the resolution at which the layer is painted.
+    ParentLayerToLayerScale presShellResolution =
+        aMetrics.GetZoom()
+        / aMetrics.mDevPixelsPerCSSPixel
+        / aMetrics.GetParentResolution()
+        * ScreenToLayerScale(1.0f);
    aUtils->SetResolution(presShellResolution.scale, presShellResolution.scale);

    // Finally, we set the displayport.
--- a/gfx/layers/client/ClientTiledPaintedLayer.cpp
+++ b/gfx/layers/client/ClientTiledPaintedLayer.cpp
@ -75,7 +75,7 @@ GetTransformToAncestorsParentLayer(Layer* aStart, const LayerMetricsWrapper& aAn
    // If the layer has a non-transient async transform then we need to apply it here
    // because it will get applied by the APZ in the compositor as well
    const FrameMetrics& metrics = iter.Metrics();
-    transform.PostScale(metrics.mPresShellResolution.scale, metrics.mPresShellResolution.scale, 1.f);
+    transform.PostScale(metrics.mResolution.scale, metrics.mResolution.scale, 1.f);
  }
  return transform;
 }
@ -167,7 +167,7 @@ ClientTiledPaintedLayer::BeginPaint()
  // Store the resolution from the displayport ancestor layer. Because this is Gecko-side,
  // before any async transforms have occurred, we can use the zoom for this.
  mPaintData.mResolution = displayportMetrics.GetZoomToParent();
-  TILING_LOG("TILING %p: Resolution %f\n", this, mPaintData.mPresShellResolution.scale);
+  TILING_LOG("TILING %p: Resolution %f\n", this, mPaintData.mResolution.scale);

  // Store the applicable composition bounds in this layer's Layer units.
  mPaintData.mTransformToCompBounds =
--- a/gfx/layers/client/TiledContentClient.cpp
+++ b/gfx/layers/client/TiledContentClient.cpp
@ -150,8 +150,9 @@ ComputeViewTransform(const FrameMetrics& aContentMetrics, const FrameMetrics& aC
  // but with aContentMetrics used in place of mLastContentPaintMetrics, because they
  // should be equivalent, modulo race conditions while transactions are inflight.

-  ParentLayerToScreenScale scale = aCompositorMetrics.mPresShellResolution
-                                 * aCompositorMetrics.GetAsyncZoom();
+  ParentLayerToScreenScale scale = aCompositorMetrics.GetZoom()
+                     / aContentMetrics.mDevPixelsPerCSSPixel
+                     / aCompositorMetrics.GetParentResolution();
  ScreenPoint translation = (aCompositorMetrics.GetScrollOffset() - aContentMetrics.GetScrollOffset())
                         * aCompositorMetrics.GetZoom();
  return ViewTransform(scale, -translation);
@ -1310,7 +1311,7 @@ ClientTiledLayerBuffer::ValidateTile(TileClient aTile,

 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
  DrawDebugOverlay(drawTarget, aTileOrigin.x * mResolution,
-                   aTileOrigin.y * mPresShellResolution, GetTileLength(), GetTileLength());
+                   aTileOrigin.y * mResolution, GetTileLength(), GetTileLength());
 #endif

  ctxt = nullptr;
@ -1366,8 +1367,8 @@ GetCompositorSideCompositionBounds(const LayerMetricsWrapper& aScrollAncestor,
                                   const ViewTransform& aAPZTransform)
 {
  Matrix4x4 nonTransientAPZUntransform = Matrix4x4::Scaling(
-    aScrollAncestor.Metrics().mPresShellResolution.scale,
-    aScrollAncestor.Metrics().mPresShellResolution.scale,
+    aScrollAncestor.Metrics().mResolution.scale,
+    aScrollAncestor.Metrics().mResolution.scale,
    1.f);
  nonTransientAPZUntransform.Invert();

--- a/gfx/layers/composite/AsyncCompositionManager.cpp
+++ b/gfx/layers/composite/AsyncCompositionManager.cpp
@ -718,7 +718,7 @@ ApplyAsyncTransformToScrollbarForContent(Layer* aScrollbar,
      // aScrollbarIsDescendant hunk below we unapply the entire async
      // transform, which includes the nontransientasync transform and would
      // normally account for the resolution.
-      scale *= metrics.mPresShellResolution.scale;
+      scale *= metrics.mResolution.scale;
    }
    scrollbarTransform.PostScale(1.f, 1.f / transientTransform._22, 1.f);
    scrollbarTransform.PostTranslate(0, -transientTransform._42 * scale, 0);
@ -726,7 +726,7 @@ ApplyAsyncTransformToScrollbarForContent(Layer* aScrollbar,
  if (aScrollbar->GetScrollbarDirection() == Layer::HORIZONTAL) {
    float scale = metrics.CalculateCompositedSizeInCssPixels().width / metrics.mScrollableRect.width;
    if (aScrollbarIsDescendant) {
-      scale *= metrics.mPresShellResolution.scale;
+      scale *= metrics.mResolution.scale;
    }
    scrollbarTransform.PostScale(1.f / transientTransform._11, 1.f, 1.f);
    scrollbarTransform.PostTranslate(-transientTransform._41 * scale, 0, 0);
@ -888,10 +888,9 @@ AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer)
  if (metrics.IsScrollable()) {
    geckoScroll = metrics.GetScrollOffset() * userZoom;
  }
-
-  LayerToScreenScale asyncZoom = userZoom / metrics.LayersPixelsPerCSSPixel();
-  ParentLayerToScreenScale scale = metrics.mPresShellResolution
-                                 * asyncZoom;
+  ParentLayerToScreenScale scale = userZoom
+                                  / metrics.mDevPixelsPerCSSPixel
+                                  / metrics.GetParentResolution();
  ScreenPoint translation = userScroll - geckoScroll;
  Matrix4x4 treeTransform = ViewTransform(scale, -translation);

@ -901,7 +900,7 @@ AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer)

  // Apply resolution scaling to the old transform - the layer tree as it is
  // doesn't have the necessary transform to display correctly.
-  oldTransform.PreScale(metrics.mPresShellResolution.scale, metrics.mPresShellResolution.scale, 1);
+  oldTransform.PreScale(metrics.mResolution.scale, metrics.mResolution.scale, 1);

  // Make sure that overscroll and under-zoom are represented in the old
  // transform so that fixed position content moves and scales accordingly.
--- a/gfx/layers/composite/LayerManagerComposite.cpp
+++ b/gfx/layers/composite/LayerManagerComposite.cpp
@ -907,7 +907,7 @@ LayerManagerComposite::ComputeRenderIntegrity()
    Layer* rootScrollable = rootScrollableLayers[0];
    const FrameMetrics& metrics = LayerMetricsWrapper::TopmostScrollableMetrics(rootScrollable);
    Matrix4x4 transform = rootScrollable->GetEffectiveTransform();
-    transform.PostScale(metrics.mPresShellResolution, metrics.mPresShellResolution, 1);
+    transform.PostScale(metrics.mResolution.scale, metrics.mResolution.scale, 1);

    // Clip the screen rect to the document bounds
    Rect documentBounds =
--- a/gfx/tests/gtest/TestAsyncPanZoomController.cpp
+++ b/gfx/tests/gtest/TestAsyncPanZoomController.cpp
@ -778,7 +778,7 @@ TEST_F(APZCBasicTester, ComplexTransform) {
  metrics.SetScrollOffset(CSSPoint(10, 10));
  metrics.mScrollableRect = CSSRect(0, 0, 50, 50);
  metrics.mCumulativeResolution = LayoutDeviceToLayerScale(2);
-  metrics.mPresShellResolution = ParentLayerToLayerScale(2);
+  metrics.mResolution = ParentLayerToLayerScale(2);
  metrics.SetZoom(CSSToScreenScale(6));
  metrics.mDevPixelsPerCSSPixel = CSSToLayoutDeviceScale(3);
  metrics.SetScrollId(FrameMetrics::START_SCROLL_ID);
--- a/layout/base/nsDisplayList.cpp
+++ b/layout/base/nsDisplayList.cpp
@ -724,10 +724,10 @@ nsDisplayScrollLayer::ComputeFrameMetrics(nsIFrame* aForFrame,
  // Only the root scrollable frame for a given presShell should pick up
  // the presShell's resolution. All the other frames are 1.0.
  if (aScrollFrame == presShell->GetRootScrollFrame()) {
-    metrics.mPresShellResolution = ParentLayerToLayerScale(presShell->GetXResolution(),
+    metrics.mResolution = ParentLayerToLayerScale(presShell->GetXResolution(),
                                                  presShell->GetYResolution());
  } else {
-    metrics.mPresShellResolution = ParentLayerToLayerScale(1.0f);
+    metrics.mResolution = ParentLayerToLayerScale(1.0f);
  }
  // The cumulative resolution is the resolution at which the scroll frame's
  // content is actually rendered. It includes the pres shell resolutions of
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@ -2802,7 +2802,7 @@ CalculateFrameMetricsForDisplayPort(nsIFrame* aScrollFrame,
    * nsLayoutUtils::GetTransformToAncestorScale(aScrollFrame).width);

  metrics.mDevPixelsPerCSSPixel = deviceScale;
-  metrics.mPresShellResolution = resolution;
+  metrics.mResolution = resolution;
  metrics.mCumulativeResolution = cumulativeResolution;
  metrics.SetZoom(deviceScale * cumulativeResolution * LayerToScreenScale(1));