gecko-dev/layout/base/MobileViewportManager.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "MobileViewportManager.h"

#include "gfxPrefs.h"
#include "LayersLogging.h"
#include "mozilla/PresShell.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/EventTarget.h"
#include "nsIFrame.h"
#include "nsLayoutUtils.h"
#include "nsViewManager.h"
#include "nsViewportInfo.h"
#include "UnitTransforms.h"

#define MVM_LOG(...)
// #define MVM_LOG(...) printf_stderr("MVM: " __VA_ARGS__)

NS_IMPL_ISUPPORTS(MobileViewportManager, nsIDOMEventListener, nsIObserver)

#define DOM_META_ADDED NS_LITERAL_STRING("DOMMetaAdded")
#define DOM_META_CHANGED NS_LITERAL_STRING("DOMMetaChanged")
#define FULL_ZOOM_CHANGE NS_LITERAL_STRING("FullZoomChange")
#define LOAD NS_LITERAL_STRING("load")
#define BEFORE_FIRST_PAINT NS_LITERAL_CSTRING("before-first-paint")

using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::layers;

MobileViewportManager::MobileViewportManager(nsIPresShell* aPresShell,
                                             Document* aDocument)
    : mDocument(aDocument),
      mPresShell(aPresShell),
      mIsFirstPaint(false),
      mPainted(false) {
  MOZ_ASSERT(mPresShell);
  MOZ_ASSERT(mDocument);

  MVM_LOG("%p: creating with presShell %p document %p\n", this, mPresShell,
          aDocument);

  if (nsCOMPtr<nsPIDOMWindowOuter> window = mDocument->GetWindow()) {
    mEventTarget = window->GetChromeEventHandler();
  }
  if (mEventTarget) {
    mEventTarget->AddEventListener(DOM_META_ADDED, this, false);
    mEventTarget->AddEventListener(DOM_META_CHANGED, this, false);
    mEventTarget->AddEventListener(FULL_ZOOM_CHANGE, this, false);
    mEventTarget->AddEventListener(LOAD, this, true);
  }

  nsCOMPtr<nsIObserverService> observerService =
      mozilla::services::GetObserverService();
  if (observerService) {
    observerService->AddObserver(this, BEFORE_FIRST_PAINT.Data(), false);
  }
}

MobileViewportManager::~MobileViewportManager() {}

void MobileViewportManager::Destroy() {
  MVM_LOG("%p: destroying\n", this);

  if (mEventTarget) {
    mEventTarget->RemoveEventListener(DOM_META_ADDED, this, false);
    mEventTarget->RemoveEventListener(DOM_META_CHANGED, this, false);
    mEventTarget->RemoveEventListener(FULL_ZOOM_CHANGE, this, false);
    mEventTarget->RemoveEventListener(LOAD, this, true);
    mEventTarget = nullptr;
  }

  nsCOMPtr<nsIObserverService> observerService =
      mozilla::services::GetObserverService();
  if (observerService) {
    observerService->RemoveObserver(this, BEFORE_FIRST_PAINT.Data());
  }

  mDocument = nullptr;
  mPresShell = nullptr;
}

void MobileViewportManager::SetRestoreResolution(
    float aResolution, LayoutDeviceIntSize aDisplaySize) {
  SetRestoreResolution(aResolution);
  ScreenIntSize restoreDisplaySize = ViewAs<ScreenPixel>(
      aDisplaySize, PixelCastJustification::LayoutDeviceIsScreenForBounds);
  mRestoreDisplaySize = Some(restoreDisplaySize);
}

void MobileViewportManager::SetRestoreResolution(float aResolution) {
  mRestoreResolution = Some(aResolution);
}

float MobileViewportManager::ComputeIntrinsicResolution() const {
  if (!mDocument || !mPresShell) {
    return 1.f;
  }

  ScreenIntSize displaySize = ViewAs<ScreenPixel>(
      mDisplaySize, PixelCastJustification::LayoutDeviceIsScreenForBounds);
  CSSToScreenScale intrinsicScale =
      ComputeIntrinsicScale(mDocument->GetViewportInfo(displaySize),
                            displaySize, mMobileViewportSize);
  CSSToLayoutDeviceScale cssToDev =
      mPresShell->GetPresContext()->CSSToDevPixelScale();
  return (intrinsicScale / cssToDev).scale;
}

mozilla::CSSToScreenScale MobileViewportManager::ComputeIntrinsicScale(
    const nsViewportInfo& aViewportInfo,
    const mozilla::ScreenIntSize& aDisplaySize,
    const mozilla::CSSSize& aViewportOrContentSize) const {
  CSSToScreenScale intrinsicScale =
      MaxScaleRatio(ScreenSize(aDisplaySize), aViewportOrContentSize);
  MVM_LOG("%p: Intrinsic computed zoom is %f\n", this, intrinsicScale.scale);
  return ClampZoom(intrinsicScale, aViewportInfo);
}

void MobileViewportManager::RequestReflow(bool aForceAdjustResolution) {
  MVM_LOG("%p: got a reflow request with force resolution: %d\n", this,
          aForceAdjustResolution);
  RefreshViewportSize(aForceAdjustResolution);
}

void MobileViewportManager::ResolutionUpdated() {
  MVM_LOG("%p: resolution updated\n", this);

  if (!mPresShell) {
    return;
  }

  if (!mPainted) {
    // Save the value, so our default zoom calculation
    // can take it into account later on.
    SetRestoreResolution(mPresShell->GetResolution());
  }
  RefreshVisualViewportSize();
}

NS_IMETHODIMP
MobileViewportManager::HandleEvent(dom::Event* event) {
  nsAutoString type;
  event->GetType(type);

  if (type.Equals(DOM_META_ADDED)) {
    MVM_LOG("%p: got a dom-meta-added event\n", this);
    RefreshViewportSize(mPainted);
  } else if (type.Equals(DOM_META_CHANGED)) {
    MVM_LOG("%p: got a dom-meta-changed event\n", this);
    RefreshViewportSize(mPainted);
  } else if (type.Equals(FULL_ZOOM_CHANGE)) {
    MVM_LOG("%p: got a full-zoom-change event\n", this);
    RefreshViewportSize(false);
  } else if (type.Equals(LOAD)) {
    MVM_LOG("%p: got a load event\n", this);
    if (!mPainted) {
      // Load event got fired before the before-first-paint message
      SetInitialViewport();
    }
  }
  return NS_OK;
}

NS_IMETHODIMP
MobileViewportManager::Observe(nsISupports* aSubject, const char* aTopic,
                               const char16_t* aData) {
  if (!mDocument) {
    return NS_OK;
  }

  if (SameCOMIdentity(aSubject, ToSupports(mDocument)) &&
      BEFORE_FIRST_PAINT.EqualsASCII(aTopic)) {
    MVM_LOG("%p: got a before-first-paint event\n", this);
    if (!mPainted) {
      // before-first-paint message arrived before load event
      SetInitialViewport();
    }
  }
  return NS_OK;
}

void MobileViewportManager::SetInitialViewport() {
  MVM_LOG("%p: setting initial viewport\n", this);
  mIsFirstPaint = true;
  mPainted = true;
  RefreshViewportSize(false);
}

CSSToScreenScale MobileViewportManager::ClampZoom(
    const CSSToScreenScale& aZoom, const nsViewportInfo& aViewportInfo) const {
  CSSToScreenScale zoom = aZoom;
  if (zoom < aViewportInfo.GetMinZoom()) {
    zoom = aViewportInfo.GetMinZoom();
    MVM_LOG("%p: Clamped to %f\n", this, zoom.scale);
  }
  if (zoom > aViewportInfo.GetMaxZoom()) {
    zoom = aViewportInfo.GetMaxZoom();
    MVM_LOG("%p: Clamped to %f\n", this, zoom.scale);
  }
  return zoom;
}

CSSToScreenScale MobileViewportManager::ScaleZoomWithDisplayWidth(
    const CSSToScreenScale& aZoom, const float& aDisplayWidthChangeRatio,
    const CSSSize& aNewViewport, const CSSSize& aOldViewport) {
  float cssViewportChangeRatio = (aOldViewport.width == 0)
                                     ? 1.0f
                                     : aNewViewport.width / aOldViewport.width;
  CSSToScreenScale newZoom(aZoom.scale * aDisplayWidthChangeRatio /
                           cssViewportChangeRatio);
  MVM_LOG("%p: Old zoom was %f, changed by %f/%f to %f\n", this, aZoom.scale,
          aDisplayWidthChangeRatio, cssViewportChangeRatio, newZoom.scale);
  return newZoom;
}

static CSSToScreenScale ResolutionToZoom(LayoutDeviceToLayerScale aResolution,
                                         CSSToLayoutDeviceScale aCssToDev) {
  return ViewTargetAs<ScreenPixel>(
      aCssToDev * aResolution / ParentLayerToLayerScale(1),
      PixelCastJustification::ScreenIsParentLayerForRoot);
}

static LayoutDeviceToLayerScale ZoomToResolution(
    CSSToScreenScale aZoom, CSSToLayoutDeviceScale aCssToDev) {
  return ViewTargetAs<ParentLayerPixel>(
             aZoom, PixelCastJustification::ScreenIsParentLayerForRoot) /
         aCssToDev * ParentLayerToLayerScale(1);
}

void MobileViewportManager::UpdateResolution(
    const nsViewportInfo& aViewportInfo, const ScreenIntSize& aDisplaySize,
    const CSSSize& aViewportOrContentSize,
    const Maybe<float>& aDisplayWidthChangeRatio, UpdateType aType) {
  if (!mPresShell || !mDocument) {
    return;
  }

  CSSToLayoutDeviceScale cssToDev =
      mPresShell->GetPresContext()->CSSToDevPixelScale();
  LayoutDeviceToLayerScale res(mPresShell->GetResolution());
  CSSToScreenScale zoom = ResolutionToZoom(res, cssToDev);
  Maybe<CSSToScreenScale> newZoom;

  ScreenIntSize compositionSize = GetCompositionSize(aDisplaySize);
  CSSToScreenScale intrinsicScale = ComputeIntrinsicScale(
      aViewportInfo, compositionSize, aViewportOrContentSize);

  if (aType == UpdateType::ViewportSize) {
    const CSSSize& viewportSize = aViewportOrContentSize;
    if (mIsFirstPaint) {
      CSSToScreenScale defaultZoom;
      if (mRestoreResolution) {
        LayoutDeviceToLayerScale restoreResolution(mRestoreResolution.value());
        CSSToScreenScale restoreZoom =
            ResolutionToZoom(restoreResolution, cssToDev);
        if (mRestoreDisplaySize) {
          CSSSize prevViewport =
              mDocument->GetViewportInfo(mRestoreDisplaySize.value()).GetSize();
          float restoreDisplayWidthChangeRatio =
              (mRestoreDisplaySize.value().width > 0)
                  ? (float)compositionSize.width /
                        (float)mRestoreDisplaySize.value().width
                  : 1.0f;

          restoreZoom = ScaleZoomWithDisplayWidth(
              restoreZoom, restoreDisplayWidthChangeRatio, viewportSize,
              prevViewport);
        }
        defaultZoom = restoreZoom;
        MVM_LOG("%p: restored zoom is %f\n", this, defaultZoom.scale);
        defaultZoom = ClampZoom(defaultZoom, aViewportInfo);
      } else {
        defaultZoom = aViewportInfo.GetDefaultZoom();
        MVM_LOG("%p: default zoom from viewport is %f\n", this,
                defaultZoom.scale);
        if (!aViewportInfo.IsDefaultZoomValid()) {
          defaultZoom = intrinsicScale;
        }
      }
      MOZ_ASSERT(aViewportInfo.GetMinZoom() <= defaultZoom &&
                 defaultZoom <= aViewportInfo.GetMaxZoom());

      // On first paint, we always consider the zoom to have changed.
      newZoom = Some(defaultZoom);
    } else {
      // If this is not a first paint, then in some cases we want to update the
      // pre- existing resolution so as to maintain how much actual content is
      // visible within the display width. Note that "actual content" may be
      // different with respect to CSS pixels because of the CSS viewport size
      // changing.
      //
      // aDisplayWidthChangeRatio is non-empty if:
      // (a) The meta-viewport tag information changes, and so the CSS viewport
      //     might change as a result. If this happens after the content has
      //     been painted, we want to adjust the zoom to compensate. OR
      // (b) The display size changed from a nonzero value to another
      //     nonzero value. This covers the case where e.g. the device was
      //     rotated, and again we want to adjust the zoom to compensate.
      // Note in particular that aDisplayWidthChangeRatio will be None if all
      // that happened was a change in the full-zoom. In this case, we still
      // want to compute a new CSS viewport, but we don't want to update the
      // resolution.
      //
      // Given the above, the algorithm below accounts for all types of changes
      // I can conceive of:
      // 1. screen size changes, CSS viewport does not (pages with no meta
      //    viewport or a fixed size viewport)
      // 2. screen size changes, CSS viewport also does (pages with a
      //    device-width viewport)
      // 3. screen size remains constant, but CSS viewport changes (meta
      //    viewport tag is added or removed)
      // 4. neither screen size nor CSS viewport changes
      if (aDisplayWidthChangeRatio) {
        // One more complication is that our current zoom level may be the
        // result of clamping to either the minimum or maximum zoom level
        // allowed by the viewport. If we naively scale the zoom level with
        // the change in the display width, we might be scaling one of these
        // clamped values. What we really want to do is to make scaling of the
        // zoom aware of these minimum and maximum clamping points, so that we
        // keep display width changes completely reversible.

        // Because of the behavior of ShrinkToDisplaySizeIfNeeded, we are
        // choosing zoom clamping points based on the content size of the
        // scrollable rect, which might different from aViewportOrContentSize.
        CSSSize contentSize = aViewportOrContentSize;
        nsIScrollableFrame* rootScrollableFrame =
            mPresShell->GetRootScrollFrameAsScrollable();
        if (rootScrollableFrame) {
          nsRect scrollableRect =
              nsLayoutUtils::CalculateScrollableRectForFrame(
                  rootScrollableFrame, nullptr);
          contentSize = CSSSize::FromAppUnits(scrollableRect.Size());
        }

        // We scale the sizes, though we only care about the scaled widths.
        ScreenSize minZoomDisplaySize =
            contentSize * aViewportInfo.GetMinZoom();
        ScreenSize maxZoomDisplaySize =
            contentSize * aViewportInfo.GetMaxZoom();

        float ratio = aDisplayWidthChangeRatio.value();
        ScreenSize newDisplaySize(aDisplaySize);
        ScreenSize oldDisplaySize = newDisplaySize / ratio;

        // To calculate an adjusted ratio, we use some combination of these
        // four values:
        float a(minZoomDisplaySize.width);
        float b(maxZoomDisplaySize.width);
        float c(oldDisplaySize.width);
        float d(newDisplaySize.width);

        // For both oldDisplaySize and aDisplaySize, the values are in one of
        // three "zones":
        // 1) Less than or equal to minZoomDisplaySize.
        // 2) Between minZoomDisplaySize and maxZoomDisplaySize.
        // 3) Greater than or equal to maxZoomDisplaySize.

        // Depending on which zone each are in, the adjusted ratio is shown in
        // the table below (using the a-b-c-d coding from above):

        //   d | 1 | 2 | 3 |
        // c   +---+---+---+
        //     | a | d | b |
        // 1   | a | a | a |
        //     +---+---+---+
        //     | a | d | b |
        // 2   | c | c | c |
        //     +---+---+---+
        //     | a | d | b |
        // 3   | b | b | b |
        //     +---+---+---+

        // Conveniently, the numerator is just d clamped to a..b, and the
        // denominator is c clamped to a..b.
        float numerator = clamped(d, a, b);
        float denominator = clamped(c, a, b);

        float adjustedRatio = numerator / denominator;
        newZoom = Some(ScaleZoomWithDisplayWidth(
            zoom, adjustedRatio, viewportSize, mMobileViewportSize));
      }
    }
  } else {  // aType == UpdateType::ContentSize
    MOZ_ASSERT(aType == UpdateType::ContentSize);
    MOZ_ASSERT(aDisplayWidthChangeRatio.isNothing());

    // We try to scale down the contents only IF the document has no
    // initial-scale AND IF it's not restored documents AND IF the resolution
    // has never been changed by APZ.
    if (!mRestoreResolution && !mPresShell->IsResolutionUpdatedByApz() &&
        !aViewportInfo.IsDefaultZoomValid()) {
      if (zoom != intrinsicScale) {
        newZoom = Some(intrinsicScale);
      }
    } else {
      // Even in other scenarios, we want to ensure that zoom level is
      // not _smaller_ than the intrinsic scale, otherwise we might be
      // trying to show regions where there is no content to show.
      CSSToScreenScale clampedZoom = zoom;

      if (clampedZoom < intrinsicScale) {
        clampedZoom = intrinsicScale;
      }

      // Also clamp to the restrictions imposed by aViewportInfo.
      clampedZoom = ClampZoom(clampedZoom, aViewportInfo);

      if (clampedZoom != zoom) {
        newZoom = Some(clampedZoom);
      }
    }
  }

  // If the zoom has changed, update the pres shell resolution accordingly.
  // This will also call UpdateVisualViewportSize, which means we can early
  // exit afterwards.
  if (newZoom) {
    LayoutDeviceToLayerScale resolution = ZoomToResolution(*newZoom, cssToDev);
    MVM_LOG("%p: setting resolution %f\n", this, resolution.scale);
    mPresShell->SetResolutionAndScaleTo(
        resolution.scale, nsIPresShell::ChangeOrigin::eMainThread);

    MVM_LOG("%p: New zoom is %f\n", this, newZoom->scale);
    return;
  }

  // The visual viewport size also depends on the display size, and needs
  // to be updated if if we didn't already update due to a zoom change.
  if (aType == UpdateType::ViewportSize) {
    UpdateVisualViewportSize(aDisplaySize, newZoom ? *newZoom : zoom);
  }
}

ScreenIntSize MobileViewportManager::GetCompositionSize(
    const ScreenIntSize& aDisplaySize) const {
  if (!mPresShell) {
    return ScreenIntSize();
  }

  ScreenIntSize compositionSize(aDisplaySize);
  ScreenMargin scrollbars =
      LayoutDeviceMargin::FromAppUnits(
          nsLayoutUtils::ScrollbarAreaToExcludeFromCompositionBoundsFor(
              mPresShell->GetRootScrollFrame()),
          mPresShell->GetPresContext()->AppUnitsPerDevPixel())
      // Scrollbars are not subject to resolution scaling, so LD pixels =
      // Screen pixels for them.
      * LayoutDeviceToScreenScale(1.0f);

  compositionSize.width -= scrollbars.LeftRight();
  compositionSize.height -= scrollbars.TopBottom();

  return compositionSize;
}

void MobileViewportManager::UpdateVisualViewportSize(
    const ScreenIntSize& aDisplaySize, const CSSToScreenScale& aZoom) {
  if (!mPresShell) {
    return;
  }

  ScreenSize compositionSize = ScreenSize(GetCompositionSize(aDisplaySize));

  CSSSize compSize = compositionSize / aZoom;
  MVM_LOG("%p: Setting VVPS %s\n", this, Stringify(compSize).c_str());
  nsLayoutUtils::SetVisualViewportSize(mPresShell, compSize);
}

void MobileViewportManager::UpdateDisplayPortMargins() {
  if (!mPresShell) {
    return;
  }

  if (nsIFrame* root = mPresShell->GetRootScrollFrame()) {
    bool hasDisplayPort = nsLayoutUtils::HasDisplayPort(root->GetContent());
    bool hasResolution = mPresShell->GetResolution() != 1.0f;
    if (!hasDisplayPort && !hasResolution) {
      // We only want to update the displayport if there is one already, or
      // add one if there's a resolution on the document (see bug 1225508
      // comment 1).
      return;
    }
    nsRect displayportBase = nsRect(
        nsPoint(0, 0), nsLayoutUtils::CalculateCompositionSizeForFrame(root));
    // We only create MobileViewportManager for root content documents. If that
    // ever changes we'd need to limit the size of this displayport base rect
    // because non-toplevel documents have no limit on their size.
    MOZ_ASSERT(mPresShell->GetPresContext()->IsRootContentDocument());
    nsLayoutUtils::SetDisplayPortBaseIfNotSet(root->GetContent(),
                                              displayportBase);
    nsIScrollableFrame* scrollable = do_QueryFrame(root);
    nsLayoutUtils::CalculateAndSetDisplayPortMargins(
        scrollable, nsLayoutUtils::RepaintMode::DoNotRepaint);
  }
}

void MobileViewportManager::RefreshVisualViewportSize() {
  // This function is a subset of RefreshViewportSize, and only updates the
  // visual viewport size.

  if (!mPresShell) {
    return;
  }

  ScreenIntSize displaySize = ViewAs<ScreenPixel>(
      mDisplaySize, PixelCastJustification::LayoutDeviceIsScreenForBounds);

  CSSToLayoutDeviceScale cssToDev =
      mPresShell->GetPresContext()->CSSToDevPixelScale();
  LayoutDeviceToLayerScale res(mPresShell->GetResolution());
  CSSToScreenScale zoom = ViewTargetAs<ScreenPixel>(
      cssToDev * res / ParentLayerToLayerScale(1),
      PixelCastJustification::ScreenIsParentLayerForRoot);

  UpdateVisualViewportSize(displaySize, zoom);
}

void MobileViewportManager::RefreshViewportSize(bool aForceAdjustResolution) {
  // This function gets called by the various triggers that may result in a
  // change of the CSS viewport. In some of these cases (e.g. the meta-viewport
  // tag changes) we want to update the resolution and in others (e.g. the full
  // zoom changing) we don't want to update the resolution. See the comment in
  // UpdateResolution for some more detail on this. An important assumption we
  // make here is that this RefreshViewportSize function will be called
  // separately for each trigger that changes. For instance it should never get
  // called such that both the full zoom and the meta-viewport tag have changed;
  // instead it would get called twice - once after each trigger changes. This
  // assumption is what allows the aForceAdjustResolution parameter to work as
  // intended; if this assumption is violated then we will need to add extra
  // complicated logic in UpdateResolution to ensure we only do the resolution
  // update in the right scenarios.

  if (!mPresShell || !mDocument) {
    return;
  }

  Maybe<float> displayWidthChangeRatio;
  LayoutDeviceIntSize newDisplaySize;
  if (nsLayoutUtils::GetContentViewerSize(mPresShell->GetPresContext(),
                                          newDisplaySize)) {
    // See the comment in UpdateResolution for why we're doing this.
    if (mDisplaySize.width > 0) {
      if (aForceAdjustResolution ||
          mDisplaySize.width != newDisplaySize.width) {
        displayWidthChangeRatio =
            Some((float)newDisplaySize.width / (float)mDisplaySize.width);
      }
    } else if (aForceAdjustResolution) {
      displayWidthChangeRatio = Some(1.0f);
    }

    MVM_LOG("%p: Display width change ratio is %f\n", this,
            displayWidthChangeRatio.valueOr(0.0f));
    mDisplaySize = newDisplaySize;
  }

  MVM_LOG("%p: Computing CSS viewport using %d,%d\n", this, mDisplaySize.width,
          mDisplaySize.height);
  if (mDisplaySize.width == 0 || mDisplaySize.height == 0) {
    // We can't do anything useful here, we should just bail out
    return;
  }

  ScreenIntSize displaySize = ViewAs<ScreenPixel>(
      mDisplaySize, PixelCastJustification::LayoutDeviceIsScreenForBounds);
  nsViewportInfo viewportInfo = mDocument->GetViewportInfo(displaySize);

  CSSSize viewport = viewportInfo.GetSize();
  MVM_LOG("%p: Computed CSS viewport %s\n", this, Stringify(viewport).c_str());

  if (!mIsFirstPaint && mMobileViewportSize == viewport) {
    // Nothing changed, so no need to do a reflow
    return;
  }

  // If it's the first-paint or the viewport changed, we need to update
  // various APZ properties (the zoom and some things that might depend on it)
  MVM_LOG("%p: Updating properties because %d || %d\n", this, mIsFirstPaint,
          mMobileViewportSize != viewport);

  if (aForceAdjustResolution ||
      nsLayoutUtils::AllowZoomingForDocument(mDocument)) {
    UpdateResolution(viewportInfo, displaySize, viewport,
                     displayWidthChangeRatio, UpdateType::ViewportSize);
  } else {
    // Even without zoom, we need to update that the visual viewport size
    // has changed.
    RefreshVisualViewportSize();
  }
  if (gfxPlatform::AsyncPanZoomEnabled()) {
    UpdateDisplayPortMargins();
  }

  CSSSize oldSize = mMobileViewportSize;

  // Update internal state.
  mMobileViewportSize = viewport;

  RefPtr<MobileViewportManager> strongThis(this);

  // Kick off a reflow.
  mPresShell->ResizeReflowIgnoreOverride(
      nsPresContext::CSSPixelsToAppUnits(viewport.width),
      nsPresContext::CSSPixelsToAppUnits(viewport.height),
      nsPresContext::CSSPixelsToAppUnits(oldSize.width),
      nsPresContext::CSSPixelsToAppUnits(oldSize.height));

  // We are going to fit the content to the display width if the initial-scale
  // is not specied and if the content is still wider than the display width.
  ShrinkToDisplaySizeIfNeeded(viewportInfo, displaySize);

  mIsFirstPaint = false;
}

void MobileViewportManager::ShrinkToDisplaySizeIfNeeded(
    nsViewportInfo& aViewportInfo, const ScreenIntSize& aDisplaySize) {
  if (!mPresShell) {
    return;
  }

  if (!nsLayoutUtils::AllowZoomingForDocument(mDocument)) {
    // If zoom is disabled, we don't scale down wider contents to fit them
    // into device screen because users won't be able to zoom out the tiny
    // contents.
    return;
  }

  nsIScrollableFrame* rootScrollableFrame =
      mPresShell->GetRootScrollFrameAsScrollable();
  if (rootScrollableFrame) {
    nsRect scrollableRect = nsLayoutUtils::CalculateScrollableRectForFrame(
        rootScrollableFrame, nullptr);
    CSSSize contentSize = CSSSize::FromAppUnits(scrollableRect.Size());
    UpdateResolution(aViewportInfo, aDisplaySize, contentSize, Nothing(),
                     UpdateType::ContentSize);
  }
}