Changeset 231095 in webkit


Ignore:
Timestamp:
Apr 27, 2018 8:35:50 AM (6 years ago)
Author:
Wenson Hsieh
Message:

[Extra zoom mode] Add a mechanism to override default viewport behaviors in extra zoom mode
​https://bugs.webkit.org/show_bug.cgi?id=185050
<rdar://problem/39624038>

Reviewed by Tim Horton.

Source/WebCore:

Currently, in extra zoom mode, there's no way for web pages to opt out of the default viewport behaviors
(namely, laying out at a larger width and shrinking to fit) when the web view is very tall and narrow. This
patch adds a new experimental viewport attribute, "min-device-width", that can be used to prevent WebKit from
automatically clamping the web view width to a greater value for the device width in this scenario.

Note that after this patch, logic that plumbs a minimumLayoutSize from WKWebView to the viewport configuration
will need to be renamed to reflect that this size is no longer the minimum layout size, but rather, the view
size that is used for viewport device dimensions by default. This refactoring will be done in a followup part.

See per-method comments below for more detail.

Test: fast/viewport/extrazoom/viewport-change-min-device-width.html

  • dom/ViewportArguments.cpp:

(WebCore::setViewportFeature):
(WebCore::operator<<):

  • dom/ViewportArguments.h:

Removes m_forceHorizontalShrinkToFit (more detail below).

  • page/ViewportConfiguration.cpp:

(WebCore::computedMinDeviceWidth):
(WebCore::ViewportConfiguration::ViewportConfiguration):
(WebCore::ViewportConfiguration::setMinimumLayoutSize):

Instead of directly setting the minimum layout size, setMinimumLayoutSize now first sets the view size (i.e. the
size we use for device-width in the viewport meta tag), and then updates the minimum layout size.

(WebCore::ViewportConfiguration::shouldOverrideDeviceWidthWithMinDeviceWidth const):

Replaces m_forceHorizontalShrinkToFit. Whether or not we shrink to fit is now determined by whether the
min-device-width attribute is actively clamping the width of the view.

(WebCore::ViewportConfiguration::shouldIgnoreHorizontalScalingConstraints const):
(WebCore::ViewportConfiguration::shouldIgnoreScalingConstraintsRegardlessOfContentSize const):
(WebCore::ViewportConfiguration::updateMinimumLayoutSize):

Computes and sets the minimum layout size using the view size, taking the minimum device width into account if
needed.

(WebCore::ViewportConfiguration::description const):
(WebCore::ViewportConfiguration::setForceHorizontalShrinkToFit): Deleted.

  • page/ViewportConfiguration.h:

Source/WebKit:

Remove the forceHorizontalViewportShrinkToFit and minimumAllowedLayoutWidth SPI hooks from WebKit, and
additionally remove all logic for plumbing viewSize to WebCore. See WebCore/ChangeLog for more information.

  • Shared/VisibleContentRectUpdateInfo.cpp:

(WebKit::VisibleContentRectUpdateInfo::encode const):
(WebKit::VisibleContentRectUpdateInfo::decode):
(WebKit::operator<<):

  • Shared/VisibleContentRectUpdateInfo.h:

(WebKit::VisibleContentRectUpdateInfo::VisibleContentRectUpdateInfo):
(WebKit::VisibleContentRectUpdateInfo::allowShrinkToFit const):
(WebKit::operator==):
(WebKit::VisibleContentRectUpdateInfo::forceHorizontalShrinkToFit const): Deleted.

  • UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView _initializeWithConfiguration:]):
(-[WKWebView activeMinimumLayoutSize:]):
(-[WKWebView _dispatchSetMinimumLayoutSize:]):
(-[WKWebView _frameOrBoundsChanged]):
(-[WKWebView _setMinimumLayoutSizeOverride:]):
(-[WKWebView _beginAnimatedResizeWithUpdates:]):
(-[WKWebView _endAnimatedResize]):
(-[WKWebView _minimumAllowedLayoutWidth]): Deleted.
(-[WKWebView _setMinimumAllowedLayoutWidth:]): Deleted.
(-[WKWebView activeMinimumLayoutSizes:]): Deleted.
(-[WKWebView _dispatchSetMinimumLayoutSize:viewSize:]): Deleted.
(-[WKWebView _setForceHorizontalViewportShrinkToFit:]): Deleted.
(-[WKWebView _forceHorizontalViewportShrinkToFit]): Deleted.

  • UIProcess/API/Cocoa/WKWebViewPrivate.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::creationParameters):

  • UIProcess/WebPageProxy.h:
  • UIProcess/ios/WKContentView.mm:

(-[WKContentView didUpdateVisibleRect:unobscuredRect:unobscuredRectInScrollViewCoordinates:obscuredInsets:unobscuredSafeAreaInsets:inputViewBounds:scale:minimumScale:inStableState:isChangingObscuredInsetsInteractively:enclosedInScrollableAncestorView:]):

  • UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::dynamicViewportSizeUpdate):
(WebKit::WebPageProxy::setViewportConfigurationMinimumLayoutSize):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::m_credentialsMessenger):

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:
  • WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::setViewportConfigurationMinimumLayoutSize):
(WebKit::WebPage::dynamicViewportSizeUpdate):
(WebKit::WebPage::updateVisibleContentRects):

Tools:

Remove a test that's no longer useful, now that the SPI it was testing is gone. This functionality is now
tested by the layout test added in this patch.

  • TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
  • TestWebKitAPI/Tests/ios/ViewportSizingTests.mm: Removed.

LayoutTests:

Add a new layout test to check that:

  • By default (with no min-device-width override), shrink-to-fit and expanded minimum layout sizes takes effect.
  • min-device-width can be used to bail out of shrink-to-fit and viewport behaviors.
  • A large min-device-width can be used to make extra zoom mode viewport heuristics even more aggressive.
  • TestExpectations:
  • fast/viewport/extrazoom/viewport-change-min-device-width.html: Added.
  • resources/ui-helper.js:

(window.UIHelper.zoomScale):
(window.UIHelper):

Location:
trunk
Files:
2 added
1 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r231092 r231095  
     12018-04-27  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [Extra zoom mode] Add a mechanism to override default viewport behaviors in extra zoom mode
     4        https://bugs.webkit.org/show_bug.cgi?id=185050
     5        <rdar://problem/39624038>
     6
     7        Reviewed by Tim Horton.
     8
     9        Add a new layout test to check that:
     10        • By default (with no `min-device-width` override), shrink-to-fit and expanded minimum layout sizes takes effect.
     11        • `min-device-width` can be used to bail out of shrink-to-fit and viewport behaviors.
     12        • A large `min-device-width` can be used to make extra zoom mode viewport heuristics even more aggressive.
     13
     14        * TestExpectations:
     15        * fast/viewport/extrazoom/viewport-change-min-device-width.html: Added.
     16        * resources/ui-helper.js:
     17        (window.UIHelper.zoomScale):
     18        (window.UIHelper):
     19
    1202018-04-27  Claudio Saavedra  <csaavedra@igalia.com>
    221

  • trunk/LayoutTests/TestExpectations

    r231065 r231095  
    2222fast/dom/Window/extrazoom [ Skip ]
    2323fast/forms/extrazoom [ Skip ]
     24fast/viewport/extrazoom [ Skip ]
    2425fast/visual-viewport/extrazoom [ Skip ]
    2526fast/visual-viewport/tiled-drawing [ Skip ]

  • trunk/LayoutTests/resources/ui-helper.js

    r231022 r231095  
    209209        });
    210210    }
     211
     212    static zoomScale()
     213    {
     214        return new Promise(resolve => {
     215            testRunner.runUIScript(`(() => {
     216                uiController.uiScriptComplete(uiController.zoomScale);
     217            })()`, resolve);
     218        });
     219    }
    211220}

  • trunk/Source/WebCore/ChangeLog

    r231094 r231095  
     12018-04-27  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [Extra zoom mode] Add a mechanism to override default viewport behaviors in extra zoom mode
     4        https://bugs.webkit.org/show_bug.cgi?id=185050
     5        <rdar://problem/39624038>
     6
     7        Reviewed by Tim Horton.
     8
     9        Currently, in extra zoom mode, there's no way for web pages to opt out of the default viewport behaviors
     10        (namely, laying out at a larger width and shrinking to fit) when the web view is very tall and narrow. This
     11        patch adds a new experimental viewport attribute, "min-device-width", that can be used to prevent WebKit from
     12        automatically clamping the web view width to a greater value for the device width in this scenario.
     13
     14        Note that after this patch, logic that plumbs a minimumLayoutSize from WKWebView to the viewport configuration
     15        will need to be renamed to reflect that this size is no longer the minimum layout size, but rather, the view
     16        size that is used for viewport device dimensions by default. This refactoring will be done in a followup part.
     17
     18        See per-method comments below for more detail.
     19
     20        Test: fast/viewport/extrazoom/viewport-change-min-device-width.html
     21
     22        * dom/ViewportArguments.cpp:
     23        (WebCore::setViewportFeature):
     24        (WebCore::operator<<):
     25        * dom/ViewportArguments.h:
     26
     27        Removes `m_forceHorizontalShrinkToFit` (more detail below).
     28
     29        * page/ViewportConfiguration.cpp:
     30        (WebCore::computedMinDeviceWidth):
     31        (WebCore::ViewportConfiguration::ViewportConfiguration):
     32        (WebCore::ViewportConfiguration::setMinimumLayoutSize):
     33
     34        Instead of directly setting the minimum layout size, setMinimumLayoutSize now first sets the view size (i.e. the
     35        size we use for `device-width` in the viewport meta tag), and then updates the minimum layout size.
     36
     37        (WebCore::ViewportConfiguration::shouldOverrideDeviceWidthWithMinDeviceWidth const):
     38
     39        Replaces `m_forceHorizontalShrinkToFit`. Whether or not we shrink to fit is now determined by whether the
     40        min-device-width attribute is actively clamping the width of the view.
     41
     42        (WebCore::ViewportConfiguration::shouldIgnoreHorizontalScalingConstraints const):
     43        (WebCore::ViewportConfiguration::shouldIgnoreScalingConstraintsRegardlessOfContentSize const):
     44        (WebCore::ViewportConfiguration::updateMinimumLayoutSize):
     45
     46        Computes and sets the minimum layout size using the view size, taking the minimum device width into account if
     47        needed.
     48
     49        (WebCore::ViewportConfiguration::description const):
     50        (WebCore::ViewportConfiguration::setForceHorizontalShrinkToFit): Deleted.
     51        * page/ViewportConfiguration.h:
     52
    1532018-04-27  Zalan Bujtas  <zalan@apple.com>
    254

  • trunk/Source/WebCore/dom/ViewportArguments.cpp

    r225227 r231095  
    421421    else if (equalLettersIgnoringASCIICase(key, "viewport-fit") && document.settings().viewportFitEnabled())
    422422        arguments.viewportFit = parseViewportFitValue(document, key, value);
     423    else if (equalLettersIgnoringASCIICase(key, "min-device-width"))
     424        arguments.minDeviceWidth = numericPrefix(document, key, value);
    423425    else
    424426        reportViewportWarning(document, UnrecognizedViewportArgumentKeyError, key);
    … …  
    476478    TextStream::IndentScope indentScope(ts);
    477479
    478     ts << "\n" << indent << "(width " << viewportArguments.width << ", minWidth " << viewportArguments.minWidth << ", maxWidth " << viewportArguments.maxWidth << ")";
     480    ts << "\n" << indent << "(width " << viewportArguments.width << ", minWidth " << viewportArguments.minWidth << ", maxWidth " << viewportArguments.maxWidth << ", minDeviceWidth " << viewportArguments.minDeviceWidth << ")";
    479481    ts << "\n" << indent << "(height " << viewportArguments.height << ", minHeight " << viewportArguments.minHeight << ", maxHeight " << viewportArguments.maxHeight << ")";
    480482    ts << "\n" << indent << "(zoom " << viewportArguments.zoom << ", minZoom " << viewportArguments.minZoom << ", maxZoom " << viewportArguments.maxZoom << ")";

  • trunk/Source/WebCore/dom/ViewportArguments.h

    r226657 r231095  
    9494    float minWidth { ValueAuto };
    9595    float maxWidth { ValueAuto };
     96    float minDeviceWidth { ValueAuto };
    9697    float height { ValueAuto };
    9798    float minHeight { ValueAuto };

  • trunk/Source/WebCore/page/ViewportConfiguration.cpp

    r230916 r231095  
    4646#endif
    4747
     48static float computedMinDeviceWidth(float minDeviceWidth)
     49{
     50    if (minDeviceWidth != ViewportArguments::ValueAuto)
     51        return minDeviceWidth;
     52
     53#if ENABLE(EXTRA_ZOOM_MODE)
     54    return 320;
     55#else
     56    return 0;
     57#endif
     58}
     59
    4860ViewportConfiguration::ViewportConfiguration()
    4961    : m_minimumLayoutSize(1024, 768)
     62    , m_viewSize(1024, 768)
    5063    , m_canIgnoreScalingConstraints(false)
    5164    , m_forceAlwaysUserScalable(false)
    52     , m_forceHorizontalShrinkToFit(false)
    5365{
    5466    // Setup a reasonable default configuration to avoid computing infinite scale/sizes.
    … …  
    8496}
    8597
    86 bool ViewportConfiguration::setMinimumLayoutSize(const FloatSize& minimumLayoutSize, const FloatSize& viewSize)
    87 {
    88     if (m_minimumLayoutSize == minimumLayoutSize && m_viewSize == viewSize)
    89         return false;
    90 
    91     m_minimumLayoutSize = minimumLayoutSize;
    92     m_viewSize = viewSize;
    93 
     98// FIXME: ViewportConfiguration::setMinimumLayoutSize is no longer an accurate name, since the minimum layout size
     99// is not necessarily the size of the view.
     100bool ViewportConfiguration::setMinimumLayoutSize(const FloatSize& minimumLayoutSize)
     101{
     102    if (m_viewSize == minimumLayoutSize)
     103        return false;
     104
     105    m_viewSize = minimumLayoutSize;
     106
     107    updateMinimumLayoutSize();
    94108    updateConfiguration();
    95109    return true;
    … …  
    103117    LOG_WITH_STREAM(Viewports, stream << "ViewportConfiguration::setViewportArguments " << viewportArguments);
    104118    m_viewportArguments = viewportArguments;
     119
     120    updateMinimumLayoutSize();
    105121    updateConfiguration();
    106     return true;
    107 }
    108 
    109 bool ViewportConfiguration::setForceHorizontalShrinkToFit(bool forceHorizontalShrinkToFit)
    110 {
    111     if (m_forceHorizontalShrinkToFit == forceHorizontalShrinkToFit)
    112         return false;
    113 
    114     m_forceHorizontalShrinkToFit = forceHorizontalShrinkToFit;
    115122    return true;
    116123}
    … …  
    131138}
    132139
     140bool ViewportConfiguration::shouldOverrideDeviceWidthWithMinDeviceWidth() const
     141{
     142    return m_viewSize.width() < computedMinDeviceWidth(m_viewportArguments.minDeviceWidth);
     143}
     144
    133145bool ViewportConfiguration::shouldIgnoreHorizontalScalingConstraints() const
    134146{
    … …  
    136148        return false;
    137149
    138     if (m_forceHorizontalShrinkToFit)
     150    if (shouldOverrideDeviceWidthWithMinDeviceWidth())
    139151        return true;
    140152
    … …  
    174186bool ViewportConfiguration::shouldIgnoreScalingConstraintsRegardlessOfContentSize() const
    175187{
    176     return m_canIgnoreScalingConstraints && m_forceHorizontalShrinkToFit;
     188    return m_canIgnoreScalingConstraints && shouldOverrideDeviceWidthWithMinDeviceWidth();
    177189}
    178190
    … …  
    362374
    363375    if (booleanViewportArgumentIsSet(m_viewportArguments.shrinkToFit))
    364         m_configuration.allowsShrinkToFit = m_viewportArguments.shrinkToFit != 0.;
     376        m_configuration.allowsShrinkToFit = shouldOverrideDeviceWidthWithMinDeviceWidth() || m_viewportArguments.shrinkToFit != 0.;
    365377
    366378    m_configuration.avoidsUnsafeArea = m_viewportArguments.viewportFit != ViewportFit::Cover;
    367379
    368380    LOG_WITH_STREAM(Viewports, stream << "ViewportConfiguration " << this << " updateConfiguration " << *this << " gives initial scale " << initialScale() << " based on contentSize " << m_contentSize << " and layout size " << layoutWidth() << "x" << layoutHeight());
     381}
     382
     383void ViewportConfiguration::updateMinimumLayoutSize()
     384{
     385    if (!m_viewSize.width() || !shouldOverrideDeviceWidthWithMinDeviceWidth()) {
     386        m_minimumLayoutSize = m_viewSize;
     387        return;
     388    }
     389
     390    auto minDeviceWidth = computedMinDeviceWidth(m_viewportArguments.minDeviceWidth);
     391    m_minimumLayoutSize = FloatSize(minDeviceWidth, std::roundf(m_viewSize.height() * (minDeviceWidth / m_viewSize.width())));
    369392}
    370393
    … …  
    510533    ts.dumpProperty("ignoring vertical scaling constraints", shouldIgnoreVerticalScalingConstraints() ? "true" : "false");
    511534    ts.dumpProperty("avoids unsafe area", avoidsUnsafeArea() ? "true" : "false");
    512     ts.dumpProperty("force horizontal shrink to fit", m_forceHorizontalShrinkToFit ? "true" : "false");
    513535   
    514536    ts.endGroup();

  • trunk/Source/WebCore/page/ViewportConfiguration.h

    r230916 r231095  
    7878
    7979    const FloatSize& minimumLayoutSize() const { return m_minimumLayoutSize; }
    80     WEBCORE_EXPORT bool setMinimumLayoutSize(const FloatSize&, const FloatSize& viewSize);
     80    WEBCORE_EXPORT bool setMinimumLayoutSize(const FloatSize&);
    8181
    8282    const ViewportArguments& viewportArguments() const { return m_viewportArguments; }
    8383    WEBCORE_EXPORT bool setViewportArguments(const ViewportArguments&);
    8484
    85     WEBCORE_EXPORT bool setForceHorizontalShrinkToFit(bool);
     85    bool shouldOverrideDeviceWidthWithMinDeviceWidth() const;
    8686
    8787    WEBCORE_EXPORT bool setCanIgnoreScalingConstraints(bool);
    … …  
    122122    bool shouldIgnoreHorizontalScalingConstraints() const;
    123123
     124    void updateMinimumLayoutSize();
     125
    124126    Parameters m_configuration;
    125127    Parameters m_defaultConfiguration;
    … …  
    131133    bool m_canIgnoreScalingConstraints;
    132134    bool m_forceAlwaysUserScalable;
    133     bool m_forceHorizontalShrinkToFit;
    134135};
    135136

  • trunk/Source/WebKit/ChangeLog

    r231090 r231095  
     12018-04-27  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [Extra zoom mode] Add a mechanism to override default viewport behaviors in extra zoom mode
     4        https://bugs.webkit.org/show_bug.cgi?id=185050
     5        <rdar://problem/39624038>
     6
     7        Reviewed by Tim Horton.
     8
     9        Remove the forceHorizontalViewportShrinkToFit and minimumAllowedLayoutWidth SPI hooks from WebKit, and
     10        additionally remove all logic for plumbing viewSize to WebCore. See WebCore/ChangeLog for more information.
     11
     12        * Shared/VisibleContentRectUpdateInfo.cpp:
     13        (WebKit::VisibleContentRectUpdateInfo::encode const):
     14        (WebKit::VisibleContentRectUpdateInfo::decode):
     15        (WebKit::operator<<):
     16        * Shared/VisibleContentRectUpdateInfo.h:
     17        (WebKit::VisibleContentRectUpdateInfo::VisibleContentRectUpdateInfo):
     18        (WebKit::VisibleContentRectUpdateInfo::allowShrinkToFit const):
     19        (WebKit::operator==):
     20        (WebKit::VisibleContentRectUpdateInfo::forceHorizontalShrinkToFit const): Deleted.
     21        * UIProcess/API/Cocoa/WKWebView.mm:
     22        (-[WKWebView _initializeWithConfiguration:]):
     23        (-[WKWebView activeMinimumLayoutSize:]):
     24        (-[WKWebView _dispatchSetMinimumLayoutSize:]):
     25        (-[WKWebView _frameOrBoundsChanged]):
     26        (-[WKWebView _setMinimumLayoutSizeOverride:]):
     27        (-[WKWebView _beginAnimatedResizeWithUpdates:]):
     28        (-[WKWebView _endAnimatedResize]):
     29        (-[WKWebView _minimumAllowedLayoutWidth]): Deleted.
     30        (-[WKWebView _setMinimumAllowedLayoutWidth:]): Deleted.
     31        (-[WKWebView activeMinimumLayoutSizes:]): Deleted.
     32        (-[WKWebView _dispatchSetMinimumLayoutSize:viewSize:]): Deleted.
     33        (-[WKWebView _setForceHorizontalViewportShrinkToFit:]): Deleted.
     34        (-[WKWebView _forceHorizontalViewportShrinkToFit]): Deleted.
     35        * UIProcess/API/Cocoa/WKWebViewPrivate.h:
     36        * UIProcess/WebPageProxy.cpp:
     37        (WebKit::WebPageProxy::creationParameters):
     38        * UIProcess/WebPageProxy.h:
     39        * UIProcess/ios/WKContentView.mm:
     40        (-[WKContentView didUpdateVisibleRect:unobscuredRect:unobscuredRectInScrollViewCoordinates:obscuredInsets:unobscuredSafeAreaInsets:inputViewBounds:scale:minimumScale:inStableState:isChangingObscuredInsetsInteractively:enclosedInScrollableAncestorView:]):
     41        * UIProcess/ios/WebPageProxyIOS.mm:
     42        (WebKit::WebPageProxy::dynamicViewportSizeUpdate):
     43        (WebKit::WebPageProxy::setViewportConfigurationMinimumLayoutSize):
     44        * WebProcess/WebPage/WebPage.cpp:
     45        (WebKit::m_credentialsMessenger):
     46        * WebProcess/WebPage/WebPage.h:
     47        * WebProcess/WebPage/WebPage.messages.in:
     48        * WebProcess/WebPage/ios/WebPageIOS.mm:
     49        (WebKit::WebPage::setViewportConfigurationMinimumLayoutSize):
     50        (WebKit::WebPage::dynamicViewportSizeUpdate):
     51        (WebKit::WebPage::updateVisibleContentRects):
     52
    1532018-04-27  Carlos Garcia Campos  <cgarcia@igalia.com>
    254

  • trunk/Source/WebKit/Shared/VisibleContentRectUpdateInfo.cpp

    r229063 r231095  
    5454    encoder << m_isChangingObscuredInsetsInteractively;
    5555    encoder << m_allowShrinkToFit;
    56     encoder << m_forceHorizontalShrinkToFit;
    5756    encoder << m_enclosedInScrollableAncestorView;
    5857}
    … …  
    9392        return false;
    9493    if (!decoder.decode(result.m_allowShrinkToFit))
    95         return false;
    96     if (!decoder.decode(result.m_forceHorizontalShrinkToFit))
    9794        return false;
    9895    if (!decoder.decode(result.m_enclosedInScrollableAncestorView))
    … …  
    135132    ts.dumpProperty("timestamp", info.timestamp().secondsSinceEpoch().value());
    136133    ts.dumpProperty("allowShrinkToFit", info.allowShrinkToFit());
    137     ts.dumpProperty("forceHorizontalShrinkToFit", info.forceHorizontalShrinkToFit());
    138134    if (info.horizontalVelocity())
    139135        ts.dumpProperty("horizontalVelocity", info.horizontalVelocity());

  • trunk/Source/WebKit/Shared/VisibleContentRectUpdateInfo.h

    r229063 r231095  
    4646    VisibleContentRectUpdateInfo() = default;
    4747
    48     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)
     48    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)
    4949        : m_exposedContentRect(exposedContentRect)
    5050        , m_unobscuredContentRect(unobscuredContentRect)
    … …  
    6464        , m_isChangingObscuredInsetsInteractively(isChangingObscuredInsetsInteractively)
    6565        , m_allowShrinkToFit(allowShrinkToFit)
    66         , m_forceHorizontalShrinkToFit(forceHorizontalShrinkToFit)
    6766        , m_enclosedInScrollableAncestorView(enclosedInScrollableAncestorView)
    6867    {
    … …  
    8281    bool isChangingObscuredInsetsInteractively() const { return m_isChangingObscuredInsetsInteractively; }
    8382    bool allowShrinkToFit() const { return m_allowShrinkToFit; }
    84     bool forceHorizontalShrinkToFit() const { return m_forceHorizontalShrinkToFit; }
    8583    bool enclosedInScrollableAncestorView() const { return m_enclosedInScrollableAncestorView; }
    8684
    … …  
    115113    bool m_isChangingObscuredInsetsInteractively { false };
    116114    bool m_allowShrinkToFit { false };
    117     bool m_forceHorizontalShrinkToFit { false };
    118115    bool m_enclosedInScrollableAncestorView { false };
    119116};
    … …  
    134131        && a.isFirstUpdateForNewViewSize() == b.isFirstUpdateForNewViewSize()
    135132        && a.allowShrinkToFit() == b.allowShrinkToFit()
    136         && a.forceHorizontalShrinkToFit() == b.forceHorizontalShrinkToFit()
    137133        && a.enclosedInScrollableAncestorView() == b.enclosedInScrollableAncestorView();
    138134}

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm

    r231022 r231095  
    182182};
    183183
    184 struct ActiveViewportLayoutSizes {
    185     WebCore::FloatSize minimumLayoutSize;
    186     WebCore::FloatSize viewSize;
    187 };
    188 
    189184#endif // PLATFORM(IOS)
    190185
    … …  
    312307
    313308    BOOL _allowsViewportShrinkToFit;
    314     BOOL _forceHorizontalViewportShrinkToFit;
    315     CGFloat _minimumAllowedLayoutWidth;
    316309
    317310    BOOL _hasCommittedLoadForMainFrame;
    … …  
    735728    _dragInteractionPolicy = _WKDragInteractionPolicyDefault;
    736729#if ENABLE(EXTRA_ZOOM_MODE)
    737     _minimumAllowedLayoutWidth = 320;
    738730    _allowsViewportShrinkToFit = YES;
    739     _forceHorizontalViewportShrinkToFit = YES;
    740731#else
    741     _minimumAllowedLayoutWidth = 0;
    742732    _allowsViewportShrinkToFit = NO;
    743     _forceHorizontalViewportShrinkToFit = NO;
    744733#endif
    745734#endif // PLATFORM(IOS)
    … …  
    25762565}
    25772566
    2578 - (CGFloat)_minimumAllowedLayoutWidth
    2579 {
    2580     return _minimumAllowedLayoutWidth;
    2581 }
    2582 
    2583 - (void)_setMinimumAllowedLayoutWidth:(CGFloat)minimumAllowedLayoutWidth
    2584 {
    2585     if (_minimumAllowedLayoutWidth == minimumAllowedLayoutWidth)
    2586         return;
    2587 
    2588     _minimumAllowedLayoutWidth = minimumAllowedLayoutWidth;
    2589 
    2590     auto sizes = [self activeMinimumLayoutSizes:self.bounds];
    2591     [self _dispatchSetMinimumLayoutSize:sizes.minimumLayoutSize viewSize:sizes.viewSize];
    2592 }
    2593 
    2594 - (ActiveViewportLayoutSizes)activeMinimumLayoutSizes:(const CGRect&)bounds
     2567- (WebCore::FloatSize)activeMinimumLayoutSize:(const CGRect&)bounds
    25952568{
    25962569    if (_overridesMinimumLayoutSize)
    2597         return { WebCore::FloatSize(_minimumLayoutSizeOverride), WebCore::FloatSize(_minimumLayoutSizeOverride) };
    2598 
    2599     ActiveViewportLayoutSizes sizes;
     2570        return WebCore::FloatSize(_minimumLayoutSizeOverride);
     2571
    26002572#if __IPHONE_OS_VERSION_MIN_REQUIRED >= 110000
    2601     sizes.viewSize = WebCore::FloatSize(UIEdgeInsetsInsetRect(CGRectMake(0, 0, bounds.size.width, bounds.size.height), self._scrollViewSystemContentInset).size);
     2573    return WebCore::FloatSize(UIEdgeInsetsInsetRect(CGRectMake(0, 0, bounds.size.width, bounds.size.height), self._scrollViewSystemContentInset).size);
    26022574#else
    2603     sizes.viewSize = WebCore::FloatSize { bounds.size };
    2604 #endif
    2605 
    2606     auto layoutWidth = std::max<float>(sizes.viewSize.width(), self._minimumAllowedLayoutWidth);
    2607     sizes.minimumLayoutSize = { layoutWidth, sizes.viewSize.height() * (layoutWidth / sizes.viewSize.width()) };
    2608     return sizes;
    2609 }
    2610 
    2611 - (void)_dispatchSetMinimumLayoutSize:(WebCore::FloatSize)minimumLayoutSize viewSize:(WebCore::FloatSize)viewSize
     2575    return WebCore::FloatSize { bounds.size };
     2576#endif
     2577}
     2578
     2579- (void)_dispatchSetMinimumLayoutSize:(WebCore::FloatSize)minimumLayoutSize
    26122580{
    26132581    if (_lastSentMinimumLayoutSize && CGSizeEqualToSize(_lastSentMinimumLayoutSize.value(), minimumLayoutSize))
    26142582        return;
    26152583
    2616     LOG_WITH_STREAM(VisibleRects, stream << "-[WKWebView " << _page->pageID() << " _dispatchSetMinimumLayoutSize:] " << minimumLayoutSize << " viewSize " << viewSize << " contentZoomScale " << contentZoomScale(self));
    2617     _page->setViewportConfigurationMinimumLayoutSize(minimumLayoutSize, viewSize);
     2584    LOG_WITH_STREAM(VisibleRects, stream << "-[WKWebView " << _page->pageID() << " _dispatchSetMinimumLayoutSize:] " << minimumLayoutSize << " contentZoomScale " << contentZoomScale(self));
     2585    _page->setViewportConfigurationMinimumLayoutSize(minimumLayoutSize);
    26182586    _lastSentMinimumLayoutSize = minimumLayoutSize;
    26192587}
    … …  
    26432611
    26442612    if (_dynamicViewportUpdateMode == DynamicViewportUpdateMode::NotResizing) {
    2645         if (!_overridesMinimumLayoutSize) {
    2646             auto sizes = [self activeMinimumLayoutSizes:self.bounds];
    2647             [self _dispatchSetMinimumLayoutSize:sizes.minimumLayoutSize viewSize:sizes.viewSize];
    2648         }
     2613        if (!_overridesMinimumLayoutSize)
     2614            [self _dispatchSetMinimumLayoutSize:[self activeMinimumLayoutSize:self.bounds]];
    26492615        if (!_overridesMaximumUnobscuredSize)
    26502616            [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(bounds.size)];
    … …  
    50324998
    50334999    if (_dynamicViewportUpdateMode == DynamicViewportUpdateMode::NotResizing)
    5034         [self _dispatchSetMinimumLayoutSize:WebCore::FloatSize(minimumLayoutSizeOverride) viewSize:WebCore::FloatSize(minimumLayoutSizeOverride)];
     5000        [self _dispatchSetMinimumLayoutSize:WebCore::FloatSize(minimumLayoutSizeOverride)];
    50355001
    50365002}
    … …  
    51395105}
    51405106
    5141 - (void)_setForceHorizontalViewportShrinkToFit:(BOOL)forceHorizontalViewportShrinkToFit
    5142 {
    5143     if (_forceHorizontalViewportShrinkToFit == forceHorizontalViewportShrinkToFit)
    5144         return;
    5145 
    5146     _forceHorizontalViewportShrinkToFit = forceHorizontalViewportShrinkToFit;
    5147     [self _scheduleVisibleContentRectUpdate];
    5148 }
    5149 
    5150 - (BOOL)_forceHorizontalViewportShrinkToFit
    5151 {
    5152     return _forceHorizontalViewportShrinkToFit;
    5153 }
    5154 
    51555107- (void)_setAllowsViewportShrinkToFit:(BOOL)allowShrinkToFit
    51565108{
    … …  
    51945146    _dynamicViewportUpdateMode = DynamicViewportUpdateMode::ResizingWithAnimation;
    51955147
    5196     auto oldSizes = [self activeMinimumLayoutSizes:self.bounds];
     5148    auto oldMinimumLayoutSize = [self activeMinimumLayoutSize:self.bounds];
    51975149    auto oldMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, oldBounds);
    51985150    int32_t oldOrientation = activeOrientation(self);
    … …  
    52025154
    52035155    CGRect newBounds = self.bounds;
    5204     auto newSizes = [self activeMinimumLayoutSizes:newBounds];
     5156    auto newMinimumLayoutSize = [self activeMinimumLayoutSize:newBounds];
    52055157    auto newMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, newBounds);
    52065158    int32_t newOrientation = activeOrientation(self);
    … …  
    52095161    CGRect contentViewBounds = [_contentView bounds];
    52105162
    5211     ASSERT_WITH_MESSAGE(!(_overridesMinimumLayoutSize && newSizes.minimumLayoutSize.isEmpty()), "Clients controlling the layout size should maintain a valid layout size to minimize layouts.");
    5212     if (CGRectIsEmpty(newBounds) || newSizes.minimumLayoutSize.isEmpty() || CGRectIsEmpty(futureUnobscuredRectInSelfCoordinates) || CGRectIsEmpty(contentViewBounds)) {
     5163    ASSERT_WITH_MESSAGE(!(_overridesMinimumLayoutSize && newMinimumLayoutSize.isEmpty()), "Clients controlling the layout size should maintain a valid layout size to minimize layouts.");
     5164    if (CGRectIsEmpty(newBounds) || newMinimumLayoutSize.isEmpty() || CGRectIsEmpty(futureUnobscuredRectInSelfCoordinates) || CGRectIsEmpty(contentViewBounds)) {
    52135165        _dynamicViewportUpdateMode = DynamicViewportUpdateMode::NotResizing;
    52145166        [self _frameOrBoundsChanged];
    52155167        if (_overridesMinimumLayoutSize)
    5216             [self _dispatchSetMinimumLayoutSize:newSizes.minimumLayoutSize viewSize:newSizes.viewSize];
     5168            [self _dispatchSetMinimumLayoutSize:newMinimumLayoutSize];
    52175169        if (_overridesMaximumUnobscuredSize)
    52185170            [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(newMaximumUnobscuredSize)];
    … …  
    52255177
    52265178    if (CGRectEqualToRect(oldBounds, newBounds)
    5227         && oldSizes.minimumLayoutSize == newSizes.minimumLayoutSize
     5179        && oldMinimumLayoutSize == newMinimumLayoutSize
    52285180        && oldMaximumUnobscuredSize == newMaximumUnobscuredSize
    52295181        && oldOrientation == newOrientation
    … …  
    52455197
    52465198    CGSize contentSizeInContentViewCoordinates = contentViewBounds.size;
    5247     [_scrollView setMinimumZoomScale:std::min(newSizes.minimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView minimumZoomScale])];
    5248     [_scrollView setMaximumZoomScale:std::max(newSizes.minimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView maximumZoomScale])];
     5199    [_scrollView setMinimumZoomScale:std::min(newMinimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView minimumZoomScale])];
     5200    [_scrollView setMaximumZoomScale:std::max(newMinimumLayoutSize.width() / contentSizeInContentViewCoordinates.width, [_scrollView maximumZoomScale])];
    52495201
    52505202    // Compute the new scale to keep the current content width in the scrollview.
    52515203    CGFloat oldWebViewWidthInContentViewCoordinates = oldUnobscuredContentRect.width();
    52525204    CGFloat visibleContentViewWidthInContentCoordinates = std::min(contentSizeInContentViewCoordinates.width, oldWebViewWidthInContentViewCoordinates);
    5253     CGFloat targetScale = newSizes.minimumLayoutSize.width() / visibleContentViewWidthInContentCoordinates;
     5205    CGFloat targetScale = newMinimumLayoutSize.width() / visibleContentViewWidthInContentCoordinates;
    52545206    CGFloat resizeAnimationViewAnimationScale = targetScale / contentZoomScale(self);
    52555207    [_resizeAnimationView setTransform:CGAffineTransformMakeScale(resizeAnimationViewAnimationScale, resizeAnimationViewAnimationScale)];
    … …  
    52915243    WebCore::FloatBoxExtent unobscuredSafeAreaInsetsExtent(unobscuredSafeAreaInsets.top, unobscuredSafeAreaInsets.right, unobscuredSafeAreaInsets.bottom, unobscuredSafeAreaInsets.left);
    52925244
    5293     _lastSentMinimumLayoutSize = newSizes.minimumLayoutSize;
     5245    _lastSentMinimumLayoutSize = newMinimumLayoutSize;
    52945246    _lastSentMaximumUnobscuredSize = newMaximumUnobscuredSize;
    52955247    _lastSentDeviceOrientation = newOrientation;
    52965248
    5297     _page->dynamicViewportSizeUpdate(newSizes.minimumLayoutSize, newSizes.viewSize, newMaximumUnobscuredSize, visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, futureUnobscuredRectInSelfCoordinates, unobscuredSafeAreaInsetsExtent, targetScale, newOrientation);
     5249    _page->dynamicViewportSizeUpdate(newMinimumLayoutSize, newMaximumUnobscuredSize, visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, futureUnobscuredRectInSelfCoordinates, unobscuredSafeAreaInsetsExtent, targetScale, newOrientation);
    52985250    if (WebKit::DrawingAreaProxy* drawingArea = _page->drawingArea())
    52995251        drawingArea->setSize(WebCore::IntSize(newBounds.size));
    … …  
    53605312
    53615313    CGRect newBounds = self.bounds;
    5362     auto newSizes = [self activeMinimumLayoutSizes:newBounds];
     5314    auto newMinimumLayoutSize = [self activeMinimumLayoutSize:newBounds];
    53635315    auto newMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, newBounds);
    53645316    int32_t newOrientation = activeOrientation(self);
    53655317
    5366     if (!_lastSentMinimumLayoutSize || newSizes.minimumLayoutSize != _lastSentMinimumLayoutSize.value())
    5367         [self _dispatchSetMinimumLayoutSize:newSizes.minimumLayoutSize viewSize:newSizes.viewSize];
     5318    if (!_lastSentMinimumLayoutSize || newMinimumLayoutSize != _lastSentMinimumLayoutSize.value())
     5319        [self _dispatchSetMinimumLayoutSize:newMinimumLayoutSize];
    53685320    if (!_lastSentMaximumUnobscuredSize || newMaximumUnobscuredSize != _lastSentMaximumUnobscuredSize.value())
    53695321        [self _dispatchSetMaximumUnobscuredSize:WebCore::FloatSize(newMaximumUnobscuredSize)];

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivate.h

    r231022 r231095  
    205205
    206206@property (nonatomic, setter=_setAllowsViewportShrinkToFit:) BOOL _allowsViewportShrinkToFit;
    207 @property (nonatomic, setter=_setForceHorizontalViewportShrinkToFit:) BOOL _forceHorizontalViewportShrinkToFit WK_API_AVAILABLE(ios(WK_IOS_TBA));
    208 @property (nonatomic, setter=_setMinimumAllowedLayoutWidth:) CGFloat _minimumAllowedLayoutWidth WK_API_AVAILABLE(ios(WK_IOS_TBA));
    209207
    210208// FIXME: Remove these three properties once we expose WKWebViewContentProvider as API.

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r231048 r231095  
    60616061    parameters.ignoresViewportScaleLimits = m_forceAlwaysUserScalable;
    60626062    parameters.viewportConfigurationMinimumLayoutSize = m_viewportConfigurationMinimumLayoutSize;
    6063     parameters.viewportConfigurationViewSize = m_viewportConfigurationViewSize;
    60646063    parameters.maximumUnobscuredSize = m_maximumUnobscuredSize;
    60656064#endif

  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r231048 r231095  
    546546    void overflowScrollDidEndScroll();
    547547
    548     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);
     548    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);
    549549    void synchronizeDynamicViewportUpdate();
    550550
    551     void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&, const WebCore::FloatSize& viewSize);
     551    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&);
    552552    void setMaximumUnobscuredSize(const WebCore::FloatSize&);
    553553    void setDeviceOrientation(int32_t);
    … …  
    21362136    bool m_forceAlwaysUserScalable { false };
    21372137    WebCore::FloatSize m_viewportConfigurationMinimumLayoutSize;
    2138     WebCore::FloatSize m_viewportConfigurationViewSize;
    21392138    WebCore::FloatSize m_maximumUnobscuredSize;
    21402139#endif

  • trunk/Source/WebKit/UIProcess/ios/WKContentView.mm

    r230448 r231095  
    403403        isChangingObscuredInsetsInteractively,
    404404        _webView._allowsViewportShrinkToFit,
    405         _webView._forceHorizontalViewportShrinkToFit,
    406405        enclosedInScrollableAncestorView,
    407406        timestamp,

  • trunk/Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm

    r230819 r231095  
    306306}
    307307
    308 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)
     308void 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)
    309309{
    310310    if (!isValid())
    … …  
    315315    m_dynamicViewportSizeUpdateWaitingForTarget = true;
    316316    m_dynamicViewportSizeUpdateWaitingForLayerTreeCommit = true;
    317     m_process->send(Messages::WebPage::DynamicViewportSizeUpdate(minimumLayoutSize, viewSize, maximumUnobscuredSize, targetExposedContentRect, targetUnobscuredRect, targetUnobscuredRectInScrollViewCoordinates, unobscuredSafeAreaInsets, targetScale, deviceOrientation, ++m_currentDynamicViewportSizeUpdateID), m_pageID);
     317    m_process->send(Messages::WebPage::DynamicViewportSizeUpdate(minimumLayoutSize, maximumUnobscuredSize, targetExposedContentRect, targetUnobscuredRect, targetUnobscuredRectInScrollViewCoordinates, unobscuredSafeAreaInsets, targetScale, deviceOrientation, ++m_currentDynamicViewportSizeUpdateID), m_pageID);
    318318}
    319319
    … …  
    355355}
    356356
    357 void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize& size, const WebCore::FloatSize& viewSize)
     357void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize& size)
    358358{
    359359    m_viewportConfigurationMinimumLayoutSize = size;
    360     m_viewportConfigurationViewSize = viewSize;
    361360
    362361    if (isValid())
    363         m_process->send(Messages::WebPage::SetViewportConfigurationMinimumLayoutSize(size, viewSize), m_pageID);
     362        m_process->send(Messages::WebPage::SetViewportConfigurationMinimumLayoutSize(size), m_pageID);
    364363}
    365364

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r231048 r231095  
    613613
    614614#if PLATFORM(IOS)
    615     setViewportConfigurationMinimumLayoutSize(parameters.viewportConfigurationMinimumLayoutSize, parameters.viewportConfigurationViewSize);
     615    setViewportConfigurationMinimumLayoutSize(parameters.viewportConfigurationMinimumLayoutSize);
    616616    setMaximumUnobscuredSize(parameters.maximumUnobscuredSize);
    617617#endif

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r230952 r231095  
    876876
    877877#if PLATFORM(IOS)
    878     void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&, const WebCore::FloatSize& viewSize);
     878    void setViewportConfigurationMinimumLayoutSize(const WebCore::FloatSize&);
    879879    void setMaximumUnobscuredSize(const WebCore::FloatSize&);
    880880    void setDeviceOrientation(int32_t);
    881     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);
     881    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);
    882882    void synchronizeDynamicViewportUpdate(double& newTargetScale, WebCore::FloatPoint& newScrollPosition, uint64_t& nextValidLayerTreeTransactionID);
    883883    std::optional<float> scaleFromUIProcess(const VisibleContentRectUpdateInfo&) const;

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

    r230834 r231095  
    4242    MouseEvent(WebKit::WebMouseEvent event)
    4343#if PLATFORM(IOS)
    44     SetViewportConfigurationMinimumLayoutSize(WebCore::FloatSize size, WebCore::FloatSize viewSize)
     44    SetViewportConfigurationMinimumLayoutSize(WebCore::FloatSize size)
    4545    SetMaximumUnobscuredSize(WebCore::FloatSize size)
    4646    SetDeviceOrientation(int32_t deviceOrientation)
    47     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)
     47    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)
    4848    SynchronizeDynamicViewportUpdate() -> (double newTargetScale, WebCore::FloatPoint newScrollPosition, uint64_t nextValidLayerTreeTransactionID)
    4949

  • trunk/Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm

    r231022 r231095  
    24552455}
    24562456
    2457 void WebPage::setViewportConfigurationMinimumLayoutSize(const FloatSize& size, const FloatSize& viewSize)
    2458 {
    2459     LOG_WITH_STREAM(VisibleRects, stream << "WebPage " << m_pageID << " setViewportConfigurationMinimumLayoutSize " << size << " viewSize " << viewSize);
    2460     if (m_viewportConfiguration.setMinimumLayoutSize(size, viewSize))
     2457void WebPage::setViewportConfigurationMinimumLayoutSize(const FloatSize& size)
     2458{
     2459    LOG_WITH_STREAM(VisibleRects, stream << "WebPage " << m_pageID << " setViewportConfigurationMinimumLayoutSize " << size);
     2460    if (m_viewportConfiguration.setMinimumLayoutSize(size))
    24612461        viewportConfigurationChanged();
    24622462}
    … …  
    24932493}
    24942494
    2495 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)
     2495void 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)
    24962496{
    24972497    SetForScope<bool> dynamicSizeUpdateGuard(m_inDynamicSizeUpdate, true);
    24982498    // FIXME: this does not handle the cases where the content would change the content size or scroll position from JavaScript.
    24992499    // To handle those cases, we would need to redo this computation on every change until the next visible content rect update.
    2500     LOG_WITH_STREAM(VisibleRects, stream << "\nWebPage::dynamicViewportSizeUpdate - minimumLayoutSize " << minimumLayoutSize << " viewSize " << viewSize << " targetUnobscuredRect " << targetUnobscuredRect << " targetExposedContentRect " << targetExposedContentRect << " targetScale " << targetScale);
     2500    LOG_WITH_STREAM(VisibleRects, stream << "\nWebPage::dynamicViewportSizeUpdate - minimumLayoutSize " << minimumLayoutSize << " targetUnobscuredRect " << targetUnobscuredRect << " targetExposedContentRect " << targetExposedContentRect << " targetScale " << targetScale);
    25012501
    25022502    FrameView& frameView = *m_page->mainFrame().view();
    … …  
    25312531
    25322532    LOG_WITH_STREAM(VisibleRects, stream << "WebPage::dynamicViewportSizeUpdate setting minimum layout size to " << minimumLayoutSize);
    2533     m_viewportConfiguration.setMinimumLayoutSize(minimumLayoutSize, viewSize);
     2533    m_viewportConfiguration.setMinimumLayoutSize(minimumLayoutSize);
    25342534    IntSize newLayoutSize = m_viewportConfiguration.layoutSize();
    25352535
    … …  
    29132913        m_dynamicSizeUpdateHistory.clear();
    29142914
    2915     bool didUpdateForceHorizontalShrinkToFit = m_viewportConfiguration.setForceHorizontalShrinkToFit(visibleContentRectUpdateInfo.forceHorizontalShrinkToFit());
    2916     bool didUpdateCanIgnoreViewportScalingConstraints = m_viewportConfiguration.setCanIgnoreScalingConstraints(m_ignoreViewportScalingConstraints && visibleContentRectUpdateInfo.allowShrinkToFit());
    2917     if (didUpdateForceHorizontalShrinkToFit || didUpdateCanIgnoreViewportScalingConstraints)
     2915    if (m_viewportConfiguration.setCanIgnoreScalingConstraints(m_ignoreViewportScalingConstraints && visibleContentRectUpdateInfo.allowShrinkToFit()))
    29182916        viewportConfigurationChanged();
    29192917

  • trunk/Tools/ChangeLog

    r231083 r231095  
     12018-04-27  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [Extra zoom mode] Add a mechanism to override default viewport behaviors in extra zoom mode
     4        https://bugs.webkit.org/show_bug.cgi?id=185050
     5        <rdar://problem/39624038>
     6
     7        Reviewed by Tim Horton.
     8
     9        Remove a test that's no longer useful, now that the SPI it was testing is gone. This functionality is now
     10        tested by the layout test added in this patch.
     11
     12        * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
     13        * TestWebKitAPI/Tests/ios/ViewportSizingTests.mm: Removed.
     14
    1152018-04-26  Ryan Haddad  <ryanhaddad@apple.com>
    216

  • trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj

    r231080 r231095  
    9595                2E1B7B001D41ABA7007558B4 /* large-video-seek-after-ending.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2E1B7AFF1D41A95F007558B4 /* large-video-seek-after-ending.html */; };
    9696                2E1B7B021D41B1B9007558B4 /* large-video-hides-controls-after-seek-to-end.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2E1B7B011D41B1B3007558B4 /* large-video-hides-controls-after-seek-to-end.html */; };
    97                 2E1B881F2040EE5300FFF6A9 /* ViewportSizingTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = 2E1B881E2040EE5300FFF6A9 /* ViewportSizingTests.mm */; };
    9897                2E1DFDED1D42A51100714A00 /* large-videos-with-audio.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2E1DFDEC1D42A41C00714A00 /* large-videos-with-audio.html */; };
    9998                2E1DFDEF1D42A6F200714A00 /* large-videos-with-audio-autoplay.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = 2E1DFDEE1D42A6EB00714A00 /* large-videos-with-audio-autoplay.html */; };
    … …  
    12571256                2E1B7AFF1D41A95F007558B4 /* large-video-seek-after-ending.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "large-video-seek-after-ending.html"; sourceTree = "<group>"; };
    12581257                2E1B7B011D41B1B3007558B4 /* large-video-hides-controls-after-seek-to-end.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "large-video-hides-controls-after-seek-to-end.html"; sourceTree = "<group>"; };
    1259                 2E1B881E2040EE5300FFF6A9 /* ViewportSizingTests.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = ViewportSizingTests.mm; sourceTree = "<group>"; };
    12601258                2E1DFDEC1D42A41C00714A00 /* large-videos-with-audio.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "large-videos-with-audio.html"; sourceTree = "<group>"; };
    12611259                2E1DFDEE1D42A6EB00714A00 /* large-videos-with-audio-autoplay.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "large-videos-with-audio-autoplay.html"; sourceTree = "<group>"; };
    … …  
    23802378                                F45033F4206BEC95009351CE /* TextAutosizingBoost.mm */,
    23812379                                F46849BD1EEF58E400B937FE /* UIPasteboardTests.mm */,
    2382                                 2E1B881E2040EE5300FFF6A9 /* ViewportSizingTests.mm */,
    23832380                                514958BD1F7427AC00E87BAD /* WKWebViewAutofillTests.mm */,
    23842381                        );
    … …  
    37693766                                7C83E0C61D0A654E00FEBCF3 /* VideoControlsManager.mm in Sources */,
    37703767                                115EB3431EE0BA03003C2C0A /* ViewportSizeForViewportUnits.mm in Sources */,
    3771                                 2E1B881F2040EE5300FFF6A9 /* ViewportSizingTests.mm in Sources */,
    37723768                                6356FB221EC4E0BA0044BF18 /* VisibleContentRect.mm in Sources */,
    37733769                                83779C381F82FECE007CDA8A /* VisitedLinkStore.mm in Sources */,
Note: See TracChangeset for help on using the changeset viewer.