Attachment 338967 Details for Bug 185067 – Test patch

[patch] Test patch

bug-185067-20180426214819.patch (text/plain), 44.56 KB, created by Wenson Hsieh on 2018-04-26 21:48:19 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Wenson Hsieh

Created: 2018-04-26 21:48:19 PDT

Size: 44.56 KB

patch

obsolete

>Subversion Revision: 231022
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index bd453214a9598cc254e1de90ce6948a2a829a1a7..c7ff0eb78713623127096686f22e7300abb026a4 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,10 @@
>+2018-04-26  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        Test bug (please ignore)
>+        https://bugs.webkit.org/show_bug.cgi?id=185067
>+
>+        Reviewed by NOBODY (OOPS!).
>+
> 2018-04-25  Ryosuke Niwa  <rniwa@webkit.org>
> 
>         PSON: Don't create a new process when navigating to a blob URL, data URL, and about:blank
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 124c673222721a3d2b823f48c56cd3786ee52ff0..769540e499559afcaedbf569ba6cde3fd9bbc30b 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,10 @@
>+2018-04-26  Wenson Hsieh  <wenson_hsieh@apple.com>
>+
>+        Test bug (please ignore)
>+        https://bugs.webkit.org/show_bug.cgi?id=185067
>+
>+        Reviewed by NOBODY (OOPS!).
>+
> 2018-04-25  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         [Extra zoom mode] The search field on www.bing.com is missing label text
>diff --git a/Source/WebCore/dom/ViewportArguments.cpp b/Source/WebCore/dom/ViewportArguments.cpp
>index ee327e53fa7410c0bc886c734e7a5c1123693c4d..71a3c5df042337e7c95acc5eef528441a8dbc726 100644
>--- a/Source/WebCore/dom/ViewportArguments.cpp
>+++ b/Source/WebCore/dom/ViewportArguments.cpp
>@@ -420,6 +420,8 @@ void setViewportFeature(ViewportArguments& arguments, Document& document, String
>         arguments.shrinkToFit = findBooleanValue(document, key, value);
>     else if (equalLettersIgnoringASCIICase(key, "viewport-fit") && document.settings().viewportFitEnabled())
>         arguments.viewportFit = parseViewportFitValue(document, key, value);
>+    else if (equalLettersIgnoringASCIICase(key, "min-device-width"))
>+        arguments.minDeviceWidth = numericPrefix(document, key, value);
>     else
>         reportViewportWarning(document, UnrecognizedViewportArgumentKeyError, key);
> }
>@@ -475,7 +477,7 @@ TextStream& operator<<(TextStream& ts, const ViewportArguments& viewportArgument
> {
>     TextStream::IndentScope indentScope(ts);
> 
>-    ts << "\n" << indent << "(width " << viewportArguments.width << ", minWidth " << viewportArguments.minWidth << ", maxWidth " << viewportArguments.maxWidth << ")";
>+    ts << "\n" << indent << "(width " << viewportArguments.width << ", minWidth " << viewportArguments.minWidth << ", maxWidth " << viewportArguments.maxWidth << ", minDeviceWidth " << viewportArguments.minDeviceWidth << ")";
>     ts << "\n" << indent << "(height " << viewportArguments.height << ", minHeight " << viewportArguments.minHeight << ", maxHeight " << viewportArguments.maxHeight << ")";
>     ts << "\n" << indent << "(zoom " << viewportArguments.zoom << ", minZoom " << viewportArguments.minZoom << ", maxZoom " << viewportArguments.maxZoom << ")";
> 
>diff --git a/Source/WebCore/dom/ViewportArguments.h b/Source/WebCore/dom/ViewportArguments.h
>index 4f1afea34001b8bbd9c26fa20b1c167de79582fb..4a8e8cbdf433cf3887248a524d44af122b167aa5 100644
>--- a/Source/WebCore/dom/ViewportArguments.h
>+++ b/Source/WebCore/dom/ViewportArguments.h
>@@ -93,6 +93,7 @@ struct ViewportArguments {
>     float width { ValueAuto };
>     float minWidth { ValueAuto };
>     float maxWidth { ValueAuto };
>+    float minDeviceWidth { ValueAuto };
>     float height { ValueAuto };
>     float minHeight { ValueAuto };
>     float maxHeight { ValueAuto };
>diff --git a/Source/WebCore/page/ViewportConfiguration.cpp b/Source/WebCore/page/ViewportConfiguration.cpp
>index e4de76f00481409ec4ec013289059aadbfd594a1..269119c2934e6d7b27a1f915f36b44f525827fb7 100644
>--- a/Source/WebCore/page/ViewportConfiguration.cpp
>+++ b/Source/WebCore/page/ViewportConfiguration.cpp
>@@ -45,11 +45,23 @@ static bool constraintsAreAllRelative(const ViewportConfiguration::Parameters& c
> }
> #endif
> 
>+static float computedMinDeviceWidth(float minDeviceWidth)
>+{
>+    if (minDeviceWidth != ViewportArguments::ValueAuto)
>+        return minDeviceWidth;
>+
>+#if ENABLE(EXTRA_ZOOM_MODE)
>+    return 320;
>+#else
>+    return 0;
>+#endif
>+}
>+
> ViewportConfiguration::ViewportConfiguration()
>     : m_minimumLayoutSize(1024, 768)
>+    , m_viewSize(1024, 768)
>     , m_canIgnoreScalingConstraints(false)
>     , m_forceAlwaysUserScalable(false)
>-    , m_forceHorizontalShrinkToFit(false)
> {
>     // Setup a reasonable default configuration to avoid computing infinite scale/sizes.
>     // Those are the original iPhone configuration.
>@@ -83,14 +95,16 @@ bool ViewportConfiguration::setContentsSize(const IntSize& contentSize)
>     return true;
> }
> 
>-bool ViewportConfiguration::setMinimumLayoutSize(const FloatSize& minimumLayoutSize, const FloatSize& viewSize)
>+// FIXME: ViewportConfiguration::setMinimumLayoutSize is no longer an accurate name, since the minimum layout size
>+// is not necessarily the size of the view.
>+bool ViewportConfiguration::setMinimumLayoutSize(const FloatSize& minimumLayoutSize)
> {
>-    if (m_minimumLayoutSize == minimumLayoutSize && m_viewSize == viewSize)
>+    if (m_viewSize == minimumLayoutSize)
>         return false;
> 
>-    m_minimumLayoutSize = minimumLayoutSize;
>-    m_viewSize = viewSize;
>+    m_viewSize = minimumLayoutSize;
> 
>+    updateMinimumLayoutSize();
>     updateConfiguration();
>     return true;
> }
>@@ -102,16 +116,9 @@ bool ViewportConfiguration::setViewportArguments(const ViewportArguments& viewpo
> 
>     LOG_WITH_STREAM(Viewports, stream << "ViewportConfiguration::setViewportArguments " << viewportArguments);
>     m_viewportArguments = viewportArguments;
>-    updateConfiguration();
>-    return true;
>-}
>-
>-bool ViewportConfiguration::setForceHorizontalShrinkToFit(bool forceHorizontalShrinkToFit)
>-{
>-    if (m_forceHorizontalShrinkToFit == forceHorizontalShrinkToFit)
>-        return false;
> 
>-    m_forceHorizontalShrinkToFit = forceHorizontalShrinkToFit;
>+    updateMinimumLayoutSize();
>+    updateConfiguration();
>     return true;
> }
> 
>@@ -130,12 +137,17 @@ IntSize ViewportConfiguration::layoutSize() const
>     return IntSize(layoutWidth(), layoutHeight());
> }
> 
>+bool ViewportConfiguration::shouldOverrideDeviceWidthWithMinDeviceWidth() const
>+{
>+    return m_viewSize.width() < computedMinDeviceWidth(m_viewportArguments.minDeviceWidth);
>+}
>+
> bool ViewportConfiguration::shouldIgnoreHorizontalScalingConstraints() const
> {
>     if (!m_canIgnoreScalingConstraints)
>         return false;
> 
>-    if (m_forceHorizontalShrinkToFit)
>+    if (shouldOverrideDeviceWidthWithMinDeviceWidth())
>         return true;
> 
>     if (!m_configuration.allowsShrinkToFit)
>@@ -173,7 +185,7 @@ bool ViewportConfiguration::shouldIgnoreScalingConstraints() const
> 
> bool ViewportConfiguration::shouldIgnoreScalingConstraintsRegardlessOfContentSize() const
> {
>-    return m_canIgnoreScalingConstraints && m_forceHorizontalShrinkToFit;
>+    return m_canIgnoreScalingConstraints && shouldOverrideDeviceWidthWithMinDeviceWidth();
> }
> 
> double ViewportConfiguration::initialScaleFromSize(double width, double height, bool shouldIgnoreScalingConstraints) const
>@@ -361,13 +373,25 @@ void ViewportConfiguration::updateConfiguration()
>         m_configuration.allowsUserScaling = m_viewportArguments.userZoom != 0.;
> 
>     if (booleanViewportArgumentIsSet(m_viewportArguments.shrinkToFit))
>-        m_configuration.allowsShrinkToFit = m_viewportArguments.shrinkToFit != 0.;
>+        m_configuration.allowsShrinkToFit = shouldOverrideDeviceWidthWithMinDeviceWidth() || m_viewportArguments.shrinkToFit != 0.;
> 
>     m_configuration.avoidsUnsafeArea = m_viewportArguments.viewportFit != ViewportFit::Cover;
> 
>     LOG_WITH_STREAM(Viewports, stream << "ViewportConfiguration " << this << " updateConfiguration " << *this << " gives initial scale " << initialScale() << " based on contentSize " << m_contentSize << " and layout size " << layoutWidth() << "x" << layoutHeight());
> }
> 
>+void ViewportConfiguration::updateMinimumLayoutSize()
>+{
>+    if (!m_viewSize.width() || !shouldOverrideDeviceWidthWithMinDeviceWidth()) {
>+        m_minimumLayoutSize = m_viewSize;
>+        return;
>+    }
>+
>+    auto minDeviceWidth = computedMinDeviceWidth(m_viewportArguments.minDeviceWidth);
>+    auto scaledDeviceHeight = std::roundf(m_viewSize.height() * (minDeviceWidth / m_viewSize.width()));
>+    m_minimumLayoutSize = FloatSize(minDeviceWidth, scaledDeviceHeight);
>+}
>+
> double ViewportConfiguration::viewportArgumentsLength(double length) const
> {
>     if (length == ViewportArguments::ValueDeviceWidth)
>@@ -509,7 +533,6 @@ String ViewportConfiguration::description() const
>     ts.dumpProperty("ignoring horizontal scaling constraints", shouldIgnoreHorizontalScalingConstraints() ? "true" : "false");
>     ts.dumpProperty("ignoring vertical scaling constraints", shouldIgnoreVerticalScalingConstraints() ? "true" : "false");
>     ts.dumpProperty("avoids unsafe area", avoidsUnsafeArea() ? "true" : "false");
>-    ts.dumpProperty("force horizontal shrink to fit", m_forceHorizontalShrinkToFit ? "true" : "false");
>     
>     ts.endGroup();
> 
>diff --git a/Source/WebCore/page/ViewportConfiguration.h b/Source/WebCore/page/ViewportConfiguration.h
>index 9ec6893a52ddfcc2cf1a9392b4aa3d13b811162b..d6a50ca45c10062997d82f5b77403caee74be94c 100644
>--- a/Source/WebCore/page/ViewportConfiguration.h
>+++ b/Source/WebCore/page/ViewportConfiguration.h
>@@ -77,12 +77,12 @@ public:
>     FloatSize viewSize() const { return m_viewSize; }
> 
>     const FloatSize& minimumLayoutSize() const { return m_minimumLayoutSize; }
>-    WEBCORE_EXPORT bool setMinimumLayoutSize(const FloatSize&, const FloatSize& viewSize);
>+    WEBCORE_EXPORT bool setMinimumLayoutSize(const FloatSize&);
> 
>     const ViewportArguments& viewportArguments() const { return m_viewportArguments; }
>     WEBCORE_EXPORT bool setViewportArguments(const ViewportArguments&);
> 
>-    WEBCORE_EXPORT bool setForceHorizontalShrinkToFit(bool);
>+    bool shouldOverrideDeviceWidthWithMinDeviceWidth() const;
> 
>     WEBCORE_EXPORT bool setCanIgnoreScalingConstraints(bool);
>     void setForceAlwaysUserScalable(bool forceAlwaysUserScalable) { m_forceAlwaysUserScalable = forceAlwaysUserScalable; }
>@@ -121,6 +121,8 @@ private:
>     bool shouldIgnoreVerticalScalingConstraints() const;
>     bool shouldIgnoreHorizontalScalingConstraints() const;
> 
>+    void updateMinimumLayoutSize();
>+
>     Parameters m_configuration;
>     Parameters m_defaultConfiguration;
>     IntSize m_contentSize;
>@@ -130,7 +132,6 @@ private:
> 
>     bool m_canIgnoreScalingConstraints;
>     bool m_forceAlwaysUserScalable;
>-    bool m_forceHorizontalShrinkToFit;
> };
> 
> WTF::TextStream& operator<<(WTF::TextStream&, const ViewportConfiguration::Parameters&);
>diff --git a/Source/WebKit/Shared/VisibleContentRectUpdateInfo.cpp b/Source/WebKit/Shared/VisibleContentRectUpdateInfo.cpp
>index 8185bca4d20ddd9668ba68d3abab68253dcbce5a..04150c1c088912b3528be579773c2d9531f95178 100644
>--- a/Source/WebKit/Shared/VisibleContentRectUpdateInfo.cpp
>+++ b/Source/WebKit/Shared/VisibleContentRectUpdateInfo.cpp
>@@ -53,7 +53,6 @@ void VisibleContentRectUpdateInfo::encode(IPC::Encoder& encoder) const
>     encoder << m_isFirstUpdateForNewViewSize;
>     encoder << m_isChangingObscuredInsetsInteractively;
>     encoder << m_allowShrinkToFit;
>-    encoder << m_forceHorizontalShrinkToFit;
>     encoder << m_enclosedInScrollableAncestorView;
> }
> 
>@@ -93,8 +92,6 @@ bool VisibleContentRectUpdateInfo::decode(IPC::Decoder& decoder, VisibleContentR
>         return false;
>     if (!decoder.decode(result.m_allowShrinkToFit))
>         return false;
>-    if (!decoder.decode(result.m_forceHorizontalShrinkToFit))
>-        return false;
>     if (!decoder.decode(result.m_enclosedInScrollableAncestorView))
>         return false;
> 
>@@ -134,7 +131,6 @@ TextStream& operator<<(TextStream& ts, const VisibleContentRectUpdateInfo& info)
> 
>     ts.dumpProperty("timestamp", info.timestamp().secondsSinceEpoch().value());
>     ts.dumpProperty("allowShrinkToFit", info.allowShrinkToFit());
>-    ts.dumpProperty("forceHorizontalShrinkToFit", info.forceHorizontalShrinkToFit());
>     if (info.horizontalVelocity())
>         ts.dumpProperty("horizontalVelocity", info.horizontalVelocity());
>     if (info.verticalVelocity())
>diff --git a/Source/WebKit/Shared/VisibleContentRectUpdateInfo.h b/Source/WebKit/Shared/VisibleContentRectUpdateInfo.h
>index d22abaaf830161565dc71349eda52d4143b1b212..5f07c2b8a85970c6c2ead542aeb9c870447eefaa 100644
>--- a/Source/WebKit/Shared/VisibleContentRectUpdateInfo.h
>+++ b/Source/WebKit/Shared/VisibleContentRectUpdateInfo.h
>@@ -45,7 +45,7 @@ class VisibleContentRectUpdateInfo {
> public:
>     VisibleContentRectUpdateInfo() = default;
> 
>-    VisibleContentRectUpdateInfo(const WebCore::FloatRect& exposedContentRect, const WebCore::FloatRect& unobscuredContentRect, const WebCore::FloatRect& unobscuredRectInScrollViewCoordinates, const WebCore::FloatRect& unobscuredContentRectRespectingInputViewBounds, const WebCore::FloatRect& customFixedPositionRect, const WebCore::FloatBoxExtent& obscuredInsets, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double scale, bool inStableState, bool isFirstUpdateForNewViewSize, bool isChangingObscuredInsetsInteractively, bool allowShrinkToFit, bool forceHorizontalShrinkToFit, bool enclosedInScrollableAncestorView, MonotonicTime timestamp, double horizontalVelocity, double verticalVelocity, double scaleChangeRate, uint64_t lastLayerTreeTransactionId)
>+    VisibleContentRectUpdateInfo(const WebCore::FloatRect& exposedContentRect, const WebCore::FloatRect& unobscuredContentRect, const WebCore::FloatRect& unobscuredRectInScrollViewCoordinates, const WebCore::FloatRect& unobscuredContentRectRespectingInputViewBounds, const WebCore::FloatRect& customFixedPositionRect, const WebCore::FloatBoxExtent& obscuredInsets, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double scale, bool inStableState, bool isFirstUpdateForNewViewSize, bool isChangingObscuredInsetsInteractively, bool allowShrinkToFit, bool enclosedInScrollableAncestorView, MonotonicTime timestamp, double horizontalVelocity, double verticalVelocity, double scaleChangeRate, uint64_t lastLayerTreeTransactionId)
>         : m_exposedContentRect(exposedContentRect)
>         , m_unobscuredContentRect(unobscuredContentRect)
>         , m_unobscuredContentRectRespectingInputViewBounds(unobscuredContentRectRespectingInputViewBounds)
>@@ -63,7 +63,6 @@ public:
>         , m_isFirstUpdateForNewViewSize(isFirstUpdateForNewViewSize)
>         , m_isChangingObscuredInsetsInteractively(isChangingObscuredInsetsInteractively)
>         , m_allowShrinkToFit(allowShrinkToFit)
>-        , m_forceHorizontalShrinkToFit(forceHorizontalShrinkToFit)
>         , m_enclosedInScrollableAncestorView(enclosedInScrollableAncestorView)
>     {
>     }
>@@ -81,7 +80,6 @@ public:
>     bool isFirstUpdateForNewViewSize() const { return m_isFirstUpdateForNewViewSize; }
>     bool isChangingObscuredInsetsInteractively() const { return m_isChangingObscuredInsetsInteractively; }
>     bool allowShrinkToFit() const { return m_allowShrinkToFit; }
>-    bool forceHorizontalShrinkToFit() const { return m_forceHorizontalShrinkToFit; }
>     bool enclosedInScrollableAncestorView() const { return m_enclosedInScrollableAncestorView; }
> 
>     MonotonicTime timestamp() const { return m_timestamp; }
>@@ -114,7 +112,6 @@ private:
>     bool m_isFirstUpdateForNewViewSize { false };
>     bool m_isChangingObscuredInsetsInteractively { false };
>     bool m_allowShrinkToFit { false };
>-    bool m_forceHorizontalShrinkToFit { false };
>     bool m_enclosedInScrollableAncestorView { false };
> };
> 
>@@ -133,7 +130,6 @@ inline bool operator==(const VisibleContentRectUpdateInfo& a, const VisibleConte
>         && a.inStableState() == b.inStableState()
>         && a.isFirstUpdateForNewViewSize() == b.isFirstUpdateForNewViewSize()
>         && a.allowShrinkToFit() == b.allowShrinkToFit()
>-        && a.forceHorizontalShrinkToFit() == b.forceHorizontalShrinkToFit()
>         && a.enclosedInScrollableAncestorView() == b.enclosedInScrollableAncestorView();
> }
> 
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm b/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm
>index 8ea437fafbcedfa66a183013759f2a093f05be3b..4a16e6d3bb7a03545c6ac8dbade947b8ef193fdf 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm
>+++ b/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm
>@@ -181,11 +181,6 @@ enum class DynamicViewportUpdateMode {
>     ResizingWithDocumentHidden,
> };
> 
>-struct ActiveViewportLayoutSizes {
>-    WebCore::FloatSize minimumLayoutSize;
>-    WebCore::FloatSize viewSize;
>-};
>-
> #endif // PLATFORM(IOS)
> 
> #if PLATFORM(IOS)
>@@ -311,8 +306,6 @@ @implementation WKWebView {
>     std::optional<int32_t> _lastSentDeviceOrientation;
> 
>     BOOL _allowsViewportShrinkToFit;
>-    BOOL _forceHorizontalViewportShrinkToFit;
>-    CGFloat _minimumAllowedLayoutWidth;
> 
>     BOOL _hasCommittedLoadForMainFrame;
>     BOOL _needsResetViewStateAfterCommitLoadForMainFrame;
>@@ -734,13 +727,9 @@ - (void)_initializeWithConfiguration:(WKWebViewConfiguration *)configuration
> #if PLATFORM(IOS)
>     _dragInteractionPolicy = _WKDragInteractionPolicyDefault;
> #if ENABLE(EXTRA_ZOOM_MODE)
>-    _minimumAllowedLayoutWidth = 320;
>     _allowsViewportShrinkToFit = YES;
>-    _forceHorizontalViewportShrinkToFit = YES;
> #else
>-    _minimumAllowedLayoutWidth = 0;
>     _allowsViewportShrinkToFit = NO;
>-    _forceHorizontalViewportShrinkToFit = NO;
> #endif
> #endif // PLATFORM(IOS)
> }
>@@ -2575,46 +2564,25 @@ - (UIEdgeInsets)_scrollViewSystemContentInset
>     return UIEdgeInsetsAdd([_scrollView _contentScrollInset], self.safeAreaInsets, [_scrollView _edgesApplyingSafeAreaInsetsToContentInset]);
> }
> 
>-- (CGFloat)_minimumAllowedLayoutWidth
>-{
>-    return _minimumAllowedLayoutWidth;
>-}
>-
>-- (void)_setMinimumAllowedLayoutWidth:(CGFloat)minimumAllowedLayoutWidth
>-{
>-    if (_minimumAllowedLayoutWidth == minimumAllowedLayoutWidth)
>-        return;
>-
>-    _minimumAllowedLayoutWidth = minimumAllowedLayoutWidth;
>-
>-    auto sizes = [self activeMinimumLayoutSizes:self.bounds];
>-    [self _dispatchSetMinimumLayoutSize:sizes.minimumLayoutSize viewSize:sizes.viewSize];
>-}
>-
>-- (ActiveViewportLayoutSizes)activeMinimumLayoutSizes:(const CGRect&)bounds
>+- (WebCore::FloatSize)activeMinimumLayoutSize:(const CGRect&)bounds
> {
>     if (_overridesMinimumLayoutSize)
>-        return { WebCore::FloatSize(_minimumLayoutSizeOverride), WebCore::FloatSize(_minimumLayoutSizeOverride) };
>+        return WebCore::FloatSize(_minimumLayoutSizeOverride);
> 
>-    ActiveViewportLayoutSizes sizes;
> #if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000
>-    sizes.viewSize = WebCore::FloatSize(UIEdgeInsetsInsetRect(CGRectMake(0, 0, bounds.size.width, bounds.size.height), self._scrollViewSystemContentInset).size);
>+    return WebCore::FloatSize(UIEdgeInsetsInsetRect(CGRectMake(0, 0, bounds.size.width, bounds.size.height), self._scrollViewSystemContentInset).size);
> #else
>-    sizes.viewSize = WebCore::FloatSize { bounds.size };
>+    return WebCore::FloatSize { bounds.size };
> #endif
>-
>-    auto layoutWidth = std::max<float>(sizes.viewSize.width(), self._minimumAllowedLayoutWidth);
>-    sizes.minimumLayoutSize = { layoutWidth, sizes.viewSize.height() * (layoutWidth / sizes.viewSize.width()) };
>-    return sizes;
> }
> 
>-- (void)_dispatchSetMinimumLayoutSize:(WebCore::FloatSize)minimumLayoutSize viewSize:(WebCore::FloatSize)viewSize
>+- (void)_dispatchSetMinimumLayoutSize:(WebCore::FloatSize)minimumLayoutSize
> {
>     if (_lastSentMinimumLayoutSize && CGSizeEqualToSize(_lastSentMinimumLayoutSize.value(), minimumLayoutSize))
>         return;
> 
>-    LOG_WITH_STREAM(VisibleRects, stream << "-[WKWebView " << _page->pageID() << " _dispatchSetMinimumLayoutSize:] " << minimumLayoutSize << " viewSize " << viewSize << " contentZoomScale " << contentZoomScale(self));
>-    _page->setViewportConfigurationMinimumLayoutSize(minimumLayoutSize, viewSize);
>+    LOG_WITH_STREAM(VisibleRects, stream << "-[WKWebView " << _page->pageID() << " _dispatchSetMinimumLayoutSize:] " << minimumLayoutSize << " contentZoomScale " << contentZoomScale(self));
>+    _page->setViewportConfigurationMinimumLayoutSize(minimumLayoutSize);
>     _lastSentMinimumLayoutSize = minimumLayoutSize;
> }
> 
>@@ -2642,10 +2610,8 @@ - (void)_frameOrBoundsChanged
>     [_scrollView setFrame:bounds];
> 
>     if (_dynamicViewportUpdateMode == DynamicViewportUpdateMode::NotResizing) {
>-        if (!_overridesMinimumLayoutSize) {
>-            auto sizes = [self activeMinimumLayoutSizes:self.bounds];
>-            [self _dispatchSetMinimumLayoutSize:sizes.minimumLayoutSize viewSize:sizes.viewSize];
>-        }
>+        if (!_overridesMinimumLayoutSize)
>+            [self _dispatchSetMinimumLayoutSize:[self activeMinimumLayoutSize:self.bounds]];
>         if (!_overridesMaximumUnobscuredSize)
>             [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(bounds.size)];
> 
>@@ -5031,7 +4997,7 @@ - (void)_setMinimumLayoutSizeOverride:(CGSize)minimumLayoutSizeOverride
>     _minimumLayoutSizeOverride = minimumLayoutSizeOverride;
> 
>     if (_dynamicViewportUpdateMode == DynamicViewportUpdateMode::NotResizing)
>-        [self _dispatchSetMinimumLayoutSize:WebCore::FloatSize(minimumLayoutSizeOverride) viewSize:WebCore::FloatSize(minimumLayoutSizeOverride)];
>+        [self _dispatchSetMinimumLayoutSize:WebCore::FloatSize(minimumLayoutSizeOverride)];
> 
> }
> 
>@@ -5138,20 +5104,6 @@ - (void)_setMaximumUnobscuredSizeOverride:(CGSize)size
>         [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(size)];
> }
> 
>-- (void)_setForceHorizontalViewportShrinkToFit:(BOOL)forceHorizontalViewportShrinkToFit
>-{
>-    if (_forceHorizontalViewportShrinkToFit == forceHorizontalViewportShrinkToFit)
>-        return;
>-
>-    _forceHorizontalViewportShrinkToFit = forceHorizontalViewportShrinkToFit;
>-    [self _scheduleVisibleContentRectUpdate];
>-}
>-
>-- (BOOL)_forceHorizontalViewportShrinkToFit
>-{
>-    return _forceHorizontalViewportShrinkToFit;
>-}
>-
> - (void)_setAllowsViewportShrinkToFit:(BOOL)allowShrinkToFit
> {
>     _allowsViewportShrinkToFit = allowShrinkToFit;
>@@ -5193,7 +5145,7 @@ - (void)_beginAnimatedResizeWithUpdates:(void (^)(void))updateBlock
> 
>     _dynamicViewportUpdateMode = DynamicViewportUpdateMode::ResizingWithAnimation;
> 
>-    auto oldSizes = [self activeMinimumLayoutSizes:self.bounds];
>+    auto oldMinimumLayoutSize = [self activeMinimumLayoutSize:self.bounds];
>     auto oldMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, oldBounds);
>     int32_t oldOrientation = activeOrientation(self);
>     UIEdgeInsets oldObscuredInsets = _obscuredInsets;
>@@ -5201,19 +5153,19 @@ - (void)_beginAnimatedResizeWithUpdates:(void (^)(void))updateBlock
>     updateBlock();
> 
>     CGRect newBounds = self.bounds;
>-    auto newSizes = [self activeMinimumLayoutSizes:newBounds];
>+    auto newMinimumLayoutSize = [self activeMinimumLayoutSize:newBounds];
>     auto newMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, newBounds);
>     int32_t newOrientation = activeOrientation(self);
>     UIEdgeInsets newObscuredInsets = _obscuredInsets;
>     CGRect futureUnobscuredRectInSelfCoordinates = UIEdgeInsetsInsetRect(newBounds, _obscuredInsets);
>     CGRect contentViewBounds = [_contentView bounds];
> 
>-    ASSERT_WITH_MESSAGE(!(_overridesMinimumLayoutSize && newSizes.minimumLayoutSize.isEmpty()), "Clients controlling the layout size should maintain a valid layout size to minimize layouts.");
>-    if (CGRectIsEmpty(newBounds) || newSizes.minimumLayoutSize.isEmpty() || CGRectIsEmpty(futureUnobscuredRectInSelfCoordinates) || CGRectIsEmpty(contentViewBounds)) {
>+    ASSERT_WITH_MESSAGE(!(_overridesMinimumLayoutSize && newMinimumLayoutSize.isEmpty()), "Clients controlling the layout size should maintain a valid layout size to minimize layouts.");
>+    if (CGRectIsEmpty(newBounds) || newMinimumLayoutSize.isEmpty() || CGRectIsEmpty(futureUnobscuredRectInSelfCoordinates) || CGRectIsEmpty(contentViewBounds)) {
>         _dynamicViewportUpdateMode = DynamicViewportUpdateMode::NotResizing;
>         [self _frameOrBoundsChanged];
>         if (_overridesMinimumLayoutSize)
>-            [self _dispatchSetMinimumLayoutSize:newSizes.minimumLayoutSize viewSize:newSizes.viewSize];
>+            [self _dispatchSetMinimumLayoutSize:newMinimumLayoutSize];
>         if (_overridesMaximumUnobscuredSize)
>             [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(newMaximumUnobscuredSize)];
>         if (_overridesInterfaceOrientation)
>@@ -5224,7 +5176,7 @@ - (void)_beginAnimatedResizeWithUpdates:(void (^)(void))updateBlock
>     }
> 
>     if (CGRectEqualToRect(oldBounds, newBounds)
>-        && oldSizes.minimumLayoutSize == newSizes.minimumLayoutSize
>+        && oldMinimumLayoutSize == newMinimumLayoutSize
>         && oldMaximumUnobscuredSize == newMaximumUnobscuredSize
>         && oldOrientation == newOrientation
>         && UIEdgeInsetsEqualToEdgeInsets(oldObscuredInsets, newObscuredInsets)) {
>@@ -5244,13 +5196,13 @@ - (void)_beginAnimatedResizeWithUpdates:(void (^)(void))updateBlock
>     [_resizeAnimationView addSubview:[_contentView unscaledView]];
> 
>     CGSize contentSizeInContentViewCoordinates = contentViewBounds.size;
>-    [_scrollView setMinimumZoomScale:std::min(newSizes.minimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView minimumZoomScale])];
>-    [_scrollView setMaximumZoomScale:std::max(newSizes.minimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView maximumZoomScale])];
>+    [_scrollView setMinimumZoomScale:std::min(newMinimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView minimumZoomScale])];
>+    [_scrollView setMaximumZoomScale:std::max(newMinimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView maximumZoomScale])];
> 
>     // Compute the new scale to keep the current content width in the scrollview.
>     CGFloat oldWebViewWidthInContentViewCoordinates = oldUnobscuredContentRect.width();
>     CGFloat visibleContentViewWidthInContentCoordinates = std::min(contentSizeInContentViewCoordinates.width, oldWebViewWidthInContentViewCoordinates);
>-    CGFloat targetScale = newSizes.minimumLayoutSize.width() / visibleContentViewWidthInContentCoordinates;
>+    CGFloat targetScale = newMinimumLayoutSize.width() / visibleContentViewWidthInContentCoordinates;
>     CGFloat resizeAnimationViewAnimationScale = targetScale / contentZoomScale(self);
>     [_resizeAnimationView setTransform:CGAffineTransformMakeScale(resizeAnimationViewAnimationScale, resizeAnimationViewAnimationScale)];
> 
>@@ -5290,11 +5242,11 @@ - (void)_beginAnimatedResizeWithUpdates:(void (^)(void))updateBlock
>     UIEdgeInsets unobscuredSafeAreaInsets = [self _computedUnobscuredSafeAreaInset];
>     WebCore::FloatBoxExtent unobscuredSafeAreaInsetsExtent(unobscuredSafeAreaInsets.top, unobscuredSafeAreaInsets.right, unobscuredSafeAreaInsets.bottom, unobscuredSafeAreaInsets.left);
> 
>-    _lastSentMinimumLayoutSize = newSizes.minimumLayoutSize;
>+    _lastSentMinimumLayoutSize = newMinimumLayoutSize;
>     _lastSentMaximumUnobscuredSize = newMaximumUnobscuredSize;
>     _lastSentDeviceOrientation = newOrientation;
> 
>-    _page->dynamicViewportSizeUpdate(newSizes.minimumLayoutSize, newSizes.viewSize, newMaximumUnobscuredSize, visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, futureUnobscuredRectInSelfCoordinates, unobscuredSafeAreaInsetsExtent, targetScale, newOrientation);
>+    _page->dynamicViewportSizeUpdate(newMinimumLayoutSize, newMaximumUnobscuredSize, visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, futureUnobscuredRectInSelfCoordinates, unobscuredSafeAreaInsetsExtent, targetScale, newOrientation);
>     if (WebKit::DrawingAreaProxy* drawingArea = _page->drawingArea())
>         drawingArea->setSize(WebCore::IntSize(newBounds.size));
> }
>@@ -5359,12 +5311,12 @@ - (void)_endAnimatedResize
>     [self _scheduleVisibleContentRectUpdate];
> 
>     CGRect newBounds = self.bounds;
>-    auto newSizes = [self activeMinimumLayoutSizes:newBounds];
>+    auto newMinimumLayoutSize = [self activeMinimumLayoutSize:newBounds];
>     auto newMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, newBounds);
>     int32_t newOrientation = activeOrientation(self);
> 
>-    if (!_lastSentMinimumLayoutSize || newSizes.minimumLayoutSize != _lastSentMinimumLayoutSize.value())
>-        [self _dispatchSetMinimumLayoutSize:newSizes.minimumLayoutSize viewSize:newSizes.viewSize];
>+    if (!_lastSentMinimumLayoutSize || newMinimumLayoutSize != _lastSentMinimumLayoutSize.value())
>+        [self _dispatchSetMinimumLayoutSize:newMinimumLayoutSize];
>     if (!_lastSentMaximumUnobscuredSize || newMaximumUnobscuredSize != _lastSentMaximumUnobscuredSize.value())
>         [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(newMaximumUnobscuredSize)];
>     if (!_lastSentDeviceOrientation || newOrientation != _lastSentDeviceOrientation.value())
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivate.h b/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivate.h
>index 8f293f8372099e21f131690ea7362f4f2fa13410..707df9217bcdf471b1800ca91ef3ca36267a8080 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivate.h
>+++ b/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivate.h
>@@ -204,8 +204,6 @@ typedef NS_OPTIONS(NSUInteger, _WKRectEdge) {
> @property (nonatomic, setter=_setInterfaceOrientationOverride:) UIInterfaceOrientation _interfaceOrientationOverride;
> 
> @property (nonatomic, setter=_setAllowsViewportShrinkToFit:) BOOL _allowsViewportShrinkToFit;
>-@property (nonatomic, setter=_setForceHorizontalViewportShrinkToFit:) BOOL _forceHorizontalViewportShrinkToFit WK_API_AVAILABLE(ios(WK_IOS_TBA));
>-@property (nonatomic, setter=_setMinimumAllowedLayoutWidth:) CGFloat _minimumAllowedLayoutWidth WK_API_AVAILABLE(ios(WK_IOS_TBA));
> 
> // FIXME: Remove these three properties once we expose WKWebViewContentProvider as API.
> @property (nonatomic, readonly, getter=_isDisplayingPDF) BOOL _displayingPDF;
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index 560b883858300ba22d653a4432b9b26cb07ee933..47b1ed64f92fc7d7aab3358221a292b80df44d2e 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -6059,7 +6059,6 @@ WebPageCreationParameters WebPageProxy::creationParameters()
>     parameters.mimeTypesWithCustomContentProviders = m_pageClient.mimeTypesWithCustomContentProviders();
>     parameters.ignoresViewportScaleLimits = m_forceAlwaysUserScalable;
>     parameters.viewportConfigurationMinimumLayoutSize = m_viewportConfigurationMinimumLayoutSize;
>-    parameters.viewportConfigurationViewSize = m_viewportConfigurationViewSize;
>     parameters.maximumUnobscuredSize = m_maximumUnobscuredSize;
> #endif
> 
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.h b/Source/WebKit/UIProcess/WebPageProxy.h
>index f12325a66afdab1cc6e33de65f66a14e1c2d6d6f..80700503731b0267e3777309c6ddb492c32ba5f2 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.h
>+++ b/Source/WebKit/UIProcess/WebPageProxy.h
>@@ -545,10 +545,10 @@ public:
>     void overflowScrollWillStartScroll();
>     void overflowScrollDidEndScroll();
> 
>-    void dynamicViewportSizeUpdate(const WebCore::FloatSize& minimumLayoutSize, const WebCore::FloatSize& viewSize, const WebCore::FloatSize& maximumUnobscuredSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation);
>+    void dynamicViewportSizeUpdate(const WebCore::FloatSize& minimumLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation);
>     void synchronizeDynamicViewportUpdate();
> 
>-    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&, const WebCore::FloatSize& viewSize);
>+    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&);
>     void setMaximumUnobscuredSize(const WebCore::FloatSize&);
>     void setDeviceOrientation(int32_t);
>     int32_t deviceOrientation() const { return m_deviceOrientation; }
>@@ -2132,7 +2132,6 @@ private:
>     std::unique_ptr<NodeAssistanceArguments> m_deferredNodeAssistanceArguments;
>     bool m_forceAlwaysUserScalable { false };
>     WebCore::FloatSize m_viewportConfigurationMinimumLayoutSize;
>-    WebCore::FloatSize m_viewportConfigurationViewSize;
>     WebCore::FloatSize m_maximumUnobscuredSize;
> #endif
> 
>diff --git a/Source/WebKit/UIProcess/ios/WKContentView.mm b/Source/WebKit/UIProcess/ios/WKContentView.mm
>index 0fa07881dcc22b209cd230a3f242e2ac57a35840..d0cbde1a9ad959655d2ed417a9f8f83d272b0dab 100644
>--- a/Source/WebKit/UIProcess/ios/WKContentView.mm
>+++ b/Source/WebKit/UIProcess/ios/WKContentView.mm
>@@ -402,7 +402,6 @@ - (void)didUpdateVisibleRect:(CGRect)visibleContentRect
>         _sizeChangedSinceLastVisibleContentRectUpdate,
>         isChangingObscuredInsetsInteractively,
>         _webView._allowsViewportShrinkToFit,
>-        _webView._forceHorizontalViewportShrinkToFit,
>         enclosedInScrollableAncestorView,
>         timestamp,
>         velocityData.horizontalVelocity,
>diff --git a/Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm b/Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm
>index 49e7c4367a8a5e3a5c0788abe0f9a7e08d04641a..f50ab2c2625ec865ffbc91df81777e68481e8206 100644
>--- a/Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm
>+++ b/Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm
>@@ -305,7 +305,7 @@ void WebPageProxy::overflowScrollDidEndScroll()
>     m_pageClient.overflowScrollDidEndScroll();
> }
> 
>-void WebPageProxy::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, const FloatSize& viewSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation)
>+void WebPageProxy::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation)
> {
>     if (!isValid())
>         return;
>@@ -314,7 +314,7 @@ void WebPageProxy::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize,
> 
>     m_dynamicViewportSizeUpdateWaitingForTarget = true;
>     m_dynamicViewportSizeUpdateWaitingForLayerTreeCommit = true;
>-    m_process->send(Messages::WebPage::DynamicViewportSizeUpdate(minimumLayoutSize, viewSize, maximumUnobscuredSize, targetExposedContentRect, targetUnobscuredRect, targetUnobscuredRectInScrollViewCoordinates, unobscuredSafeAreaInsets, targetScale, deviceOrientation, ++m_currentDynamicViewportSizeUpdateID), m_pageID);
>+    m_process->send(Messages::WebPage::DynamicViewportSizeUpdate(minimumLayoutSize, maximumUnobscuredSize, targetExposedContentRect, targetUnobscuredRect, targetUnobscuredRectInScrollViewCoordinates, unobscuredSafeAreaInsets, targetScale, deviceOrientation, ++m_currentDynamicViewportSizeUpdateID), m_pageID);
> }
> 
> void WebPageProxy::synchronizeDynamicViewportUpdate()
>@@ -354,13 +354,12 @@ void WebPageProxy::synchronizeDynamicViewportUpdate()
>     m_dynamicViewportSizeUpdateWaitingForLayerTreeCommit = false;
> }
> 
>-void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize& size, const WebCore::FloatSize& viewSize)
>+void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize& size)
> {
>     m_viewportConfigurationMinimumLayoutSize = size;
>-    m_viewportConfigurationViewSize = viewSize;
> 
>     if (isValid())
>-        m_process->send(Messages::WebPage::SetViewportConfigurationMinimumLayoutSize(size, viewSize), m_pageID);
>+        m_process->send(Messages::WebPage::SetViewportConfigurationMinimumLayoutSize(size), m_pageID);
> }
> 
> void WebPageProxy::setForceAlwaysUserScalable(bool userScalable)
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>index a0da712b54d45fb021013b0cf083205dcdb55b3e..fb4402a4f2f831dd3b67b37a9afb4f4b22d30056 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>@@ -612,7 +612,7 @@ WebPage::WebPage(uint64_t pageID, WebPageCreationParameters&& parameters)
> #endif
> 
> #if PLATFORM(IOS)
>-    setViewportConfigurationMinimumLayoutSize(parameters.viewportConfigurationMinimumLayoutSize, parameters.viewportConfigurationViewSize);
>+    setViewportConfigurationMinimumLayoutSize(parameters.viewportConfigurationMinimumLayoutSize);
>     setMaximumUnobscuredSize(parameters.maximumUnobscuredSize);
> #endif
> }
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.h b/Source/WebKit/WebProcess/WebPage/WebPage.h
>index bf5f68c380625ee9f1ee949c31b1ebcf373a46ef..ea652ff5f32a7be8e71d162e5e4e57aa17df88ef 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.h
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.h
>@@ -875,10 +875,10 @@ public:
>     void updateVisibilityState(bool isInitialState = false);
> 
> #if PLATFORM(IOS)
>-    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&, const WebCore::FloatSize& viewSize);
>+    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&);
>     void setMaximumUnobscuredSize(const WebCore::FloatSize&);
>     void setDeviceOrientation(int32_t);
>-    void dynamicViewportSizeUpdate(const WebCore::FloatSize& minimumLayoutSize, const WebCore::FloatSize& viewSize, const WebCore::FloatSize& maximumUnobscuredSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID);
>+    void dynamicViewportSizeUpdate(const WebCore::FloatSize& minimumLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID);
>     void synchronizeDynamicViewportUpdate(double& newTargetScale, WebCore::FloatPoint& newScrollPosition, uint64_t& nextValidLayerTreeTransactionID);
>     std::optional<float> scaleFromUIProcess(const VisibleContentRectUpdateInfo&) const;
>     void updateVisibleContentRects(const VisibleContentRectUpdateInfo&, MonotonicTime oldestTimestamp);
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.messages.in b/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>index 6def3b05ad1525faee8d6b4223e5ceaeabf89b7e..d2c684d7f2f0f97a7b41e983d5b2f45cd0f8bdcd 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>@@ -41,10 +41,10 @@ messages -> WebPage LegacyReceiver {
>     KeyEvent(WebKit::WebKeyboardEvent event)
>     MouseEvent(WebKit::WebMouseEvent event)
> #if PLATFORM(IOS)
>-    SetViewportConfigurationMinimumLayoutSize(WebCore::FloatSize size, WebCore::FloatSize viewSize)
>+    SetViewportConfigurationMinimumLayoutSize(WebCore::FloatSize size)
>     SetMaximumUnobscuredSize(WebCore::FloatSize size)
>     SetDeviceOrientation(int32_t deviceOrientation)
>-    DynamicViewportSizeUpdate(WebCore::FloatSize minimumLayoutSize, WebCore::FloatSize viewSize, WebCore::FloatSize maximumUnobscuredSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, WebCore::FloatRect targetUnobscuredRectInScrollViewCoordinates, WebCore::RectEdges<float> targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID)
>+    DynamicViewportSizeUpdate(WebCore::FloatSize minimumLayoutSize, WebCore::FloatSize maximumUnobscuredSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, WebCore::FloatRect targetUnobscuredRectInScrollViewCoordinates, WebCore::RectEdges<float> targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID)
>     SynchronizeDynamicViewportUpdate() -> (double newTargetScale, WebCore::FloatPoint newScrollPosition, uint64_t nextValidLayerTreeTransactionID)
> 
>     HandleTap(WebCore::IntPoint point, uint64_t lastLayerTreeTransactionId)
>diff --git a/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm b/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
>index 5ced48b0b3f25620e7e0f703067d5da6b5e57926..e47584d579d31e0848d6367322e7c772474dcc21 100644
>--- a/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
>+++ b/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm
>@@ -2454,10 +2454,10 @@ void WebPage::autofillLoginCredentials(const String& username, const String& pas
>     }
> }
> 
>-void WebPage::setViewportConfigurationMinimumLayoutSize(const FloatSize& size, const FloatSize& viewSize)
>+void WebPage::setViewportConfigurationMinimumLayoutSize(const FloatSize& size)
> {
>-    LOG_WITH_STREAM(VisibleRects, stream << "WebPage " << m_pageID << " setViewportConfigurationMinimumLayoutSize " << size << " viewSize " << viewSize);
>-    if (m_viewportConfiguration.setMinimumLayoutSize(size, viewSize))
>+    LOG_WITH_STREAM(VisibleRects, stream << "WebPage " << m_pageID << " setViewportConfigurationMinimumLayoutSize " << size);
>+    if (m_viewportConfiguration.setMinimumLayoutSize(size))
>         viewportConfigurationChanged();
> }
> 
>@@ -2492,12 +2492,12 @@ void WebPage::resetTextAutosizing()
>     }
> }
> 
>-void WebPage::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, const FloatSize& viewSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& targetUnobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID)
>+void WebPage::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& targetUnobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID)
> {
>     SetForScope<bool> dynamicSizeUpdateGuard(m_inDynamicSizeUpdate, true);
>     // FIXME: this does not handle the cases where the content would change the content size or scroll position from JavaScript.
>     // To handle those cases, we would need to redo this computation on every change until the next visible content rect update.
>-    LOG_WITH_STREAM(VisibleRects, stream << "\nWebPage::dynamicViewportSizeUpdate - minimumLayoutSize " << minimumLayoutSize << " viewSize " << viewSize << " targetUnobscuredRect " << targetUnobscuredRect << " targetExposedContentRect " << targetExposedContentRect << " targetScale " << targetScale);
>+    LOG_WITH_STREAM(VisibleRects, stream << "\nWebPage::dynamicViewportSizeUpdate - minimumLayoutSize " << minimumLayoutSize << " targetUnobscuredRect " << targetUnobscuredRect << " targetExposedContentRect " << targetExposedContentRect << " targetScale " << targetScale);
> 
>     FrameView& frameView = *m_page->mainFrame().view();
>     IntSize oldContentSize = frameView.contentsSize();
>@@ -2530,7 +2530,7 @@ void WebPage::dynamicViewportSizeUpdate(const FloatSize& minimumLayoutSize, cons
>     }
> 
>     LOG_WITH_STREAM(VisibleRects, stream << "WebPage::dynamicViewportSizeUpdate setting minimum layout size to " << minimumLayoutSize);
>-    m_viewportConfiguration.setMinimumLayoutSize(minimumLayoutSize, viewSize);
>+    m_viewportConfiguration.setMinimumLayoutSize(minimumLayoutSize);
>     IntSize newLayoutSize = m_viewportConfiguration.layoutSize();
> 
>     if (setFixedLayoutSize(newLayoutSize))
>@@ -2912,9 +2912,7 @@ void WebPage::updateVisibleContentRects(const VisibleContentRectUpdateInfo& visi
>     if (scrollPosition != frameView.scrollPosition())
>         m_dynamicSizeUpdateHistory.clear();
> 
>-    bool didUpdateForceHorizontalShrinkToFit = m_viewportConfiguration.setForceHorizontalShrinkToFit(visibleContentRectUpdateInfo.forceHorizontalShrinkToFit());
>-    bool didUpdateCanIgnoreViewportScalingConstraints = m_viewportConfiguration.setCanIgnoreScalingConstraints(m_ignoreViewportScalingConstraints && visibleContentRectUpdateInfo.allowShrinkToFit());
>-    if (didUpdateForceHorizontalShrinkToFit || didUpdateCanIgnoreViewportScalingConstraints)
>+    if (m_viewportConfiguration.setCanIgnoreScalingConstraints(m_ignoreViewportScalingConstraints && visibleContentRectUpdateInfo.allowShrinkToFit()))
>         viewportConfigurationChanged();
> 
>     frameView.setUnobscuredContentSize(visibleContentRectUpdateInfo.unobscuredContentRect().size());

Actions: View | Formatted Diff | Diff

Attachments on bug 185067: 338967 | 339114