/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* 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 "nsIDOMEvent.h" #include "nsIFrame.h" #include "nsLayoutUtils.h" #include "nsPresShell.h" #include "nsViewManager.h" #include "nsViewportInfo.h" #include "UnitTransforms.h" #include "nsIDocument.h" #define MVM_LOG(...) // #define MVM_LOG(...) printf_stderr("MVM: " __VA_ARGS__) NS_IMPL_ISUPPORTS(MobileViewportManager, nsIDOMEventListener, nsIObserver) static const nsLiteralString DOM_META_ADDED = NS_LITERAL_STRING("DOMMetaAdded"); static const nsLiteralString DOM_META_CHANGED = NS_LITERAL_STRING("DOMMetaChanged"); static const nsLiteralString FULL_ZOOM_CHANGE = NS_LITERAL_STRING("FullZoomChange"); static const nsLiteralString LOAD = NS_LITERAL_STRING("load"); static const nsLiteralCString BEFORE_FIRST_PAINT = NS_LITERAL_CSTRING("before-first-paint"); using namespace mozilla; using namespace mozilla::layers; MobileViewportManager::MobileViewportManager(nsIPresShell* aPresShell, nsIDocument* 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) { mRestoreResolution = Some(aResolution); ScreenIntSize restoreDisplaySize = ViewAs<ScreenPixel>(aDisplaySize, PixelCastJustification::LayoutDeviceIsScreenForBounds); mRestoreDisplaySize = Some(restoreDisplaySize); } void MobileViewportManager::RequestReflow() { MVM_LOG("%p: got a reflow request\n", this); RefreshViewportSize(false); } void MobileViewportManager::ResolutionUpdated() { MVM_LOG("%p: resolution updated\n", this); RefreshSPCSPS(); } NS_IMETHODIMP MobileViewportManager::HandleEvent(nsIDOMEvent* 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 (SameCOMIdentity(aSubject, 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) { 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; } LayoutDeviceToLayerScale MobileViewportManager::ScaleResolutionWithDisplayWidth(const LayoutDeviceToLayerScale& aRes, const float& aDisplayWidthChangeRatio, const CSSSize& aNewViewport, const CSSSize& aOldViewport) { float cssViewportChangeRatio = (aOldViewport.width == 0) ? 1.0f : aNewViewport.width / aOldViewport.width; LayoutDeviceToLayerScale newRes(aRes.scale * aDisplayWidthChangeRatio / cssViewportChangeRatio); MVM_LOG("%p: Old resolution was %f, changed by %f/%f to %f\n", this, aRes.scale, aDisplayWidthChangeRatio, cssViewportChangeRatio, newRes.scale); return newRes; } CSSToScreenScale MobileViewportManager::UpdateResolution(const nsViewportInfo& aViewportInfo, const ScreenIntSize& aDisplaySize, const CSSSize& aViewport, const Maybe<float>& aDisplayWidthChangeRatio) { CSSToLayoutDeviceScale cssToDev = mPresShell->GetPresContext()->CSSToDevPixelScale(); LayoutDeviceToLayerScale res(mPresShell->GetResolution()); if (mIsFirstPaint) { CSSToScreenScale defaultZoom; if (mRestoreResolution) { LayoutDeviceToLayerScale restoreResolution(mRestoreResolution.value()); if (mRestoreDisplaySize) { CSSSize prevViewport = mDocument->GetViewportInfo(mRestoreDisplaySize.value()).GetSize(); float restoreDisplayWidthChangeRatio = (mRestoreDisplaySize.value().width > 0) ? (float)aDisplaySize.width / (float)mRestoreDisplaySize.value().width : 1.0f; restoreResolution = ScaleResolutionWithDisplayWidth(restoreResolution, restoreDisplayWidthChangeRatio, aViewport, prevViewport); } defaultZoom = CSSToScreenScale(restoreResolution.scale * cssToDev.scale); 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 = MaxScaleRatio(ScreenSize(aDisplaySize), aViewport); MVM_LOG("%p: Intrinsic computed zoom is %f\n", this, defaultZoom.scale); defaultZoom = ClampZoom(defaultZoom, aViewportInfo); } } MOZ_ASSERT(aViewportInfo.GetMinZoom() <= defaultZoom && defaultZoom <= aViewportInfo.GetMaxZoom()); CSSToParentLayerScale zoom = ViewTargetAs<ParentLayerPixel>(defaultZoom, PixelCastJustification::ScreenIsParentLayerForRoot); LayoutDeviceToLayerScale resolution = zoom / cssToDev * ParentLayerToLayerScale(1); MVM_LOG("%p: setting resolution %f\n", this, resolution.scale); mPresShell->SetResolutionAndScaleTo(resolution.scale); return defaultZoom; } // 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) { res = ScaleResolutionWithDisplayWidth(res, aDisplayWidthChangeRatio.value(), aViewport, mMobileViewportSize); mPresShell->SetResolutionAndScaleTo(res.scale); } return ViewTargetAs<ScreenPixel>(cssToDev * res / ParentLayerToLayerScale(1), PixelCastJustification::ScreenIsParentLayerForRoot); } void MobileViewportManager::UpdateSPCSPS(const ScreenIntSize& aDisplaySize, const CSSToScreenScale& aZoom) { ScreenSize 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(); CSSSize compSize = compositionSize / aZoom; MVM_LOG("%p: Setting SPCSPS %s\n", this, Stringify(compSize).c_str()); nsLayoutUtils::SetScrollPositionClampingScrollPortSize(mPresShell, compSize); } void MobileViewportManager::UpdateDisplayPortMargins() { if (nsIFrame* root = mPresShell->GetRootScrollFrame()) { bool hasDisplayPort = nsLayoutUtils::HasDisplayPort(root->GetContent()); bool hasResolution = mPresShell->ScaleToResolution() && 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; } nsIScrollableFrame* scrollable = do_QueryFrame(root); nsLayoutUtils::CalculateAndSetDisplayPortMargins(scrollable, nsLayoutUtils::RepaintMode::DoNotRepaint); } } void MobileViewportManager::RefreshSPCSPS() { // This function is a subset of RefreshViewportSize, and only updates the // SPCSPS. if (!gfxPrefs::APZAllowZooming()) { 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); UpdateSPCSPS(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. 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 (gfxPrefs::APZAllowZooming()) { CSSToScreenScale zoom = UpdateResolution(viewportInfo, displaySize, viewport, displayWidthChangeRatio); MVM_LOG("%p: New zoom is %f\n", this, zoom.scale); UpdateSPCSPS(displaySize, zoom); } if (gfxPlatform::AsyncPanZoomEnabled()) { UpdateDisplayPortMargins(); } CSSSize oldSize = mMobileViewportSize; // Update internal state. mIsFirstPaint = false; mMobileViewportSize = viewport; // Kick off a reflow. mPresShell->ResizeReflowIgnoreOverride( nsPresContext::CSSPixelsToAppUnits(viewport.width), nsPresContext::CSSPixelsToAppUnits(viewport.height), nsPresContext::CSSPixelsToAppUnits(oldSize.width), nsPresContext::CSSPixelsToAppUnits(oldSize.height)); }