summaryrefslogtreecommitdiffstats
path: root/gfx/layers/apz/test/gtest/mvm
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/layers/apz/test/gtest/mvm')
-rw-r--r--gfx/layers/apz/test/gtest/mvm/TestMobileViewportManager.cpp220
-rw-r--r--gfx/layers/apz/test/gtest/mvm/moz.build13
2 files changed, 233 insertions, 0 deletions
diff --git a/gfx/layers/apz/test/gtest/mvm/TestMobileViewportManager.cpp b/gfx/layers/apz/test/gtest/mvm/TestMobileViewportManager.cpp
new file mode 100644
index 0000000000..cd7e0a7d0d
--- /dev/null
+++ b/gfx/layers/apz/test/gtest/mvm/TestMobileViewportManager.cpp
@@ -0,0 +1,220 @@
+/* -*- 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 "gtest/gtest.h"
+#include "gmock/gmock.h"
+
+#include <functional>
+
+#include "MobileViewportManager.h"
+#include "mozilla/MVMContext.h"
+#include "mozilla/dom/Event.h"
+
+using namespace mozilla;
+
+class MockMVMContext : public MVMContext {
+ using AutoSizeFlag = nsViewportInfo::AutoSizeFlag;
+ using AutoScaleFlag = nsViewportInfo::AutoScaleFlag;
+ using ZoomFlag = nsViewportInfo::ZoomFlag;
+
+ // A "layout function" is a function that computes the content size
+ // as a function of the ICB size.
+ using LayoutFunction = std::function<CSSSize(CSSSize aICBSize)>;
+
+ public:
+ // MVMContext methods we don't care to implement.
+ MOCK_METHOD3(AddEventListener,
+ void(const nsAString& aType, nsIDOMEventListener* aListener,
+ bool aUseCapture));
+ MOCK_METHOD3(RemoveEventListener,
+ void(const nsAString& aType, nsIDOMEventListener* aListener,
+ bool aUseCapture));
+ MOCK_METHOD3(AddObserver, void(nsIObserver* aObserver, const char* aTopic,
+ bool aOwnsWeak));
+ MOCK_METHOD2(RemoveObserver,
+ void(nsIObserver* aObserver, const char* aTopic));
+ MOCK_METHOD0(Destroy, void());
+
+ MOCK_METHOD1(SetVisualViewportSize, void(const CSSSize& aSize));
+ MOCK_METHOD0(PostVisualViewportResizeEventByDynamicToolbar, void());
+ MOCK_METHOD0(UpdateDisplayPortMargins, void());
+
+ void SetMVM(MobileViewportManager* aMVM) { mMVM = aMVM; }
+
+ // MVMContext method implementations.
+ nsViewportInfo GetViewportInfo(const ScreenIntSize& aDisplaySize) const {
+ // This is a very basic approximation of what Document::GetViewportInfo()
+ // does in the most common cases.
+ // Ideally, we would invoke the algorithm in Document::GetViewportInfo()
+ // itself, but that would require refactoring it a bit to remove
+ // dependencies on the actual Document which we don't have available in
+ // this test harness.
+ CSSSize viewportSize = mDisplaySize / mDeviceScale;
+ if (mAutoSizeFlag == AutoSizeFlag::FixedSize) {
+ viewportSize = CSSSize(mFixedViewportWidth,
+ mFixedViewportWidth * (float(mDisplaySize.height) /
+ mDisplaySize.width));
+ }
+ return nsViewportInfo(mDefaultScale, mMinScale, mMaxScale, viewportSize,
+ mAutoSizeFlag, mAutoScaleFlag, mZoomFlag,
+ dom::ViewportFitType::Auto);
+ }
+ CSSToLayoutDeviceScale CSSToDevPixelScale() const { return mDeviceScale; }
+ float GetResolution() const { return mResolution; }
+ bool SubjectMatchesDocument(nsISupports* aSubject) const { return true; }
+ Maybe<CSSRect> CalculateScrollableRectForRSF() const {
+ return Some(CSSRect(CSSPoint(), mContentSize));
+ }
+ bool IsResolutionUpdatedByApz() const { return false; }
+ LayoutDeviceMargin ScrollbarAreaToExcludeFromCompositionBounds() const {
+ return LayoutDeviceMargin();
+ }
+ Maybe<LayoutDeviceIntSize> GetContentViewerSize() const {
+ return Some(mDisplaySize);
+ }
+ bool AllowZoomingForDocument() const { return true; }
+ bool IsInReaderMode() const { return false; }
+ bool IsDocumentLoading() const { return false; }
+
+ void SetResolutionAndScaleTo(float aResolution,
+ ResolutionChangeOrigin aOrigin) {
+ mResolution = aResolution;
+ mMVM->ResolutionUpdated(aOrigin);
+ }
+ void Reflow(const CSSSize& aNewSize) {
+ mICBSize = aNewSize;
+ mContentSize = mLayoutFunction(mICBSize);
+ }
+
+ // Allow test code to modify the input metrics.
+ void SetMinScale(CSSToScreenScale aMinScale) { mMinScale = aMinScale; }
+ void SetMaxScale(CSSToScreenScale aMaxScale) { mMaxScale = aMaxScale; }
+ void SetInitialScale(CSSToScreenScale aInitialScale) {
+ mDefaultScale = aInitialScale;
+ mAutoScaleFlag = AutoScaleFlag::FixedScale;
+ }
+ void SetFixedViewportWidth(CSSCoord aWidth) {
+ mFixedViewportWidth = aWidth;
+ mAutoSizeFlag = AutoSizeFlag::FixedSize;
+ }
+ void SetDisplaySize(const LayoutDeviceIntSize& aNewDisplaySize) {
+ mDisplaySize = aNewDisplaySize;
+ }
+ void SetLayoutFunction(const LayoutFunction& aLayoutFunction) {
+ mLayoutFunction = aLayoutFunction;
+ }
+
+ // Allow test code to query the output metrics.
+ CSSSize GetICBSize() const { return mICBSize; }
+ CSSSize GetContentSize() const { return mContentSize; }
+
+ private:
+ // Input metrics, with some sensible defaults.
+ LayoutDeviceIntSize mDisplaySize{300, 600};
+ CSSToScreenScale mDefaultScale{1.0f};
+ CSSToScreenScale mMinScale{0.25f};
+ CSSToScreenScale mMaxScale{10.0f};
+ CSSToLayoutDeviceScale mDeviceScale{1.0f};
+ CSSCoord mFixedViewportWidth;
+ AutoSizeFlag mAutoSizeFlag = AutoSizeFlag::AutoSize;
+ AutoScaleFlag mAutoScaleFlag = AutoScaleFlag::AutoScale;
+ ZoomFlag mZoomFlag = ZoomFlag::AllowZoom;
+ // As a default layout function, just set the content size to the ICB size.
+ LayoutFunction mLayoutFunction = [](CSSSize aICBSize) { return aICBSize; };
+
+ // Output metrics.
+ float mResolution = 1.0f;
+ CSSSize mICBSize;
+ CSSSize mContentSize;
+
+ MobileViewportManager* mMVM = nullptr;
+};
+
+class MVMTester : public ::testing::Test {
+ public:
+ MVMTester()
+ : mMVMContext(new MockMVMContext()),
+ mMVM(new MobileViewportManager(
+ mMVMContext,
+ MobileViewportManager::ManagerType::VisualAndMetaViewport)) {
+ mMVMContext->SetMVM(mMVM.get());
+ }
+
+ void Resize(const LayoutDeviceIntSize& aNewDisplaySize) {
+ mMVMContext->SetDisplaySize(aNewDisplaySize);
+ mMVM->RequestReflow(false);
+ }
+
+ protected:
+ RefPtr<MockMVMContext> mMVMContext;
+ RefPtr<MobileViewportManager> mMVM;
+};
+
+TEST_F(MVMTester, ZoomBoundsRespectedAfterRotation_Bug1536755) {
+ // Set up initial conditions.
+ mMVMContext->SetDisplaySize(LayoutDeviceIntSize(600, 300));
+ mMVMContext->SetInitialScale(CSSToScreenScale(1.0f));
+ mMVMContext->SetMinScale(CSSToScreenScale(1.0f));
+ mMVMContext->SetMaxScale(CSSToScreenScale(1.0f));
+ // Set a layout function that simulates a page which is twice
+ // as tall as it is wide.
+ mMVMContext->SetLayoutFunction([](CSSSize aICBSize) {
+ return CSSSize(aICBSize.width, aICBSize.width * 2);
+ });
+
+ // Perform an initial viewport computation and reflow, and
+ // sanity-check the results.
+ mMVM->SetInitialViewport();
+ EXPECT_EQ(CSSSize(600, 300), mMVMContext->GetICBSize());
+ EXPECT_EQ(CSSSize(600, 1200), mMVMContext->GetContentSize());
+ EXPECT_EQ(1.0f, mMVMContext->GetResolution());
+
+ // Now rotate the screen, and check that the minimum and maximum
+ // scales are still respected after the rotation.
+ Resize(LayoutDeviceIntSize(300, 600));
+ EXPECT_EQ(CSSSize(300, 600), mMVMContext->GetICBSize());
+ EXPECT_EQ(CSSSize(300, 600), mMVMContext->GetContentSize());
+ EXPECT_EQ(1.0f, mMVMContext->GetResolution());
+}
+
+TEST_F(MVMTester, LandscapeToPortraitRotation_Bug1523844) {
+ // Set up initial conditions.
+ mMVMContext->SetDisplaySize(LayoutDeviceIntSize(300, 600));
+ // Set a layout function that simulates a page with a fixed
+ // content size that's as wide as the screen in one orientation
+ // (and wider in the other).
+ mMVMContext->SetLayoutFunction(
+ [](CSSSize aICBSize) { return CSSSize(600, 1200); });
+
+ // Simulate a "DOMMetaAdded" event being fired before calling
+ // SetInitialViewport(). This matches what typically happens
+ // during real usage (the MVM receives the "DOMMetaAdded"
+ // before the "load", and it's the "load" that calls
+ // SetInitialViewport()), and is important to trigger this
+ // bug, because it causes the MVM to be stuck with an
+ // "mRestoreResolution" (prior to the fix).
+ mMVM->HandleDOMMetaAdded();
+
+ // Perform an initial viewport computation and reflow, and
+ // sanity-check the results.
+ mMVM->SetInitialViewport();
+ EXPECT_EQ(CSSSize(300, 600), mMVMContext->GetICBSize());
+ EXPECT_EQ(CSSSize(600, 1200), mMVMContext->GetContentSize());
+ EXPECT_EQ(0.5f, mMVMContext->GetResolution());
+
+ // Rotate to landscape.
+ Resize(LayoutDeviceIntSize(600, 300));
+ EXPECT_EQ(CSSSize(600, 300), mMVMContext->GetICBSize());
+ EXPECT_EQ(CSSSize(600, 1200), mMVMContext->GetContentSize());
+ EXPECT_EQ(1.0f, mMVMContext->GetResolution());
+
+ // Rotate back to portrait and check that we have returned
+ // to the portrait resolution.
+ Resize(LayoutDeviceIntSize(300, 600));
+ EXPECT_EQ(CSSSize(300, 600), mMVMContext->GetICBSize());
+ EXPECT_EQ(CSSSize(600, 1200), mMVMContext->GetContentSize());
+ EXPECT_EQ(0.5f, mMVMContext->GetResolution());
+}
diff --git a/gfx/layers/apz/test/gtest/mvm/moz.build b/gfx/layers/apz/test/gtest/mvm/moz.build
new file mode 100644
index 0000000000..0fa985307b
--- /dev/null
+++ b/gfx/layers/apz/test/gtest/mvm/moz.build
@@ -0,0 +1,13 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+UNIFIED_SOURCES += [
+ "TestMobileViewportManager.cpp",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul-gtest"