⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 237087 in webkit


Ignore:
Timestamp:
Oct 12, 2018, 4:13:37 PM (8 years ago)
Author:
Wenson Hsieh
Message:

[iOS] Allow SPI clients to lay out at arbitrarily scaled sizes and scale to fit the view
​https://bugs.webkit.org/show_bug.cgi?id=190504
<rdar://problem/45117760>

Reviewed by Tim Horton.

Source/WebCore:

Add support in ViewportConfiguration for applying a layout size scale factor to the viewport. See below for
more details.

Tests: fast/viewport/ios/constant-width-viewport-after-changing-view-scale.html

fast/viewport/ios/device-width-viewport-after-changing-view-scale.html

  • page/ViewportConfiguration.cpp:

(WebCore::ViewportConfiguration::setViewLayoutSize):

The viewport's layout size may now be changed alongside the layout size scale factor. If either of these two
variables change, we recompute our minimum layout size and viewport configuration parameters.

(WebCore::ViewportConfiguration::shouldIgnoreHorizontalScalingConstraints const):
(WebCore::ViewportConfiguration::nativeWebpageParameters):
(WebCore::ViewportConfiguration::testingParameters):
(WebCore::ViewportConfiguration::updateConfiguration):

Multiply the minimum scale, initial scale, and maximum scale by the layout size scale factor. This allows us to
keep the document well-proportioned within the viewport, while still laying out at a different layout size.

(WebCore::ViewportConfiguration::updateMinimumLayoutSize):

Compute the minimum layout size by scaling the default layout size derived from our view's size.

(WebCore::ViewportConfiguration::layoutWidth const):
(WebCore::ViewportConfiguration::layoutHeight const):

  • page/ViewportConfiguration.h:

Maintain the original initial scale, unaffected by the layout size scale factor. This is used when computing
layout width and height to prevent scaling by the layout size scale factor twice when computing layout sizes.

(WebCore::ViewportConfiguration::description const):

Include the layout size scale factor in ViewportConfiguration's description string.

(WebCore::ViewportConfiguration::Parameters::operator== const):
(WebCore::operator<<):

Source/WebKit:

Add support for _setViewScale: and _viewScale on iOS. While similar in concept to macOS, changing this property
on iOS uses viewport configurations to change the minimum layout size of the document and apply view scaling.
Setting the view scale on iOS to a value s multiplies the minimium layout size by a factor 1 / s, but also
multiplies the initial, minimum and maximum scales by a factor of s. The net effect of applying this scale
causes the page to lay out at a larger width and shrink (or a smaller width and expand) to fit the viewport.

  • Shared/WebPageCreationParameters.cpp:

(WebKit::WebPageCreationParameters::encode const):
(WebKit::WebPageCreationParameters::decode):

  • Shared/WebPageCreationParameters.h:

Send viewportConfigurationLayoutSizeScaleFactor alongside viewportConfigurationViewLayoutSize.

(-[WKWebView _dispatchSetViewLayoutSize:]):
(-[WKWebView _viewScale]):
(-[WKWebView _setViewScale:]):

Provide a different implementation of _setViewScale: on iOS, by scaling the effective minimum layout size.
(See above for more detail).

  • UIProcess/API/Cocoa/WKWebViewPrivate.h:

Add missing API availability annotations for the _viewScale property.

  • UIProcess/API/mac/WKView.mm:

(-[WKView _setViewScale:]):

  • UIProcess/Cocoa/WebViewImpl.mm:

Both -[WKView _setViewScale:] and -[WKWebView _setViewScale:] throw Objective C exceptions upon receiving a bad
argument (e.g. scale <= 0). However, logic for throwing this exception is specific to iOS in WKWebView, and
handled in WebViewImpl on macOS. To make this less confusing, move the exception throwing code out of
!PLATFORM(MAC) in WKWebView, and move the path for raising this exception in WKView on macOS from WebViewImpl to
WKView.

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::creationParameters):

  • UIProcess/WebPageProxy.h:

(WebKit::WebPageProxy::layoutSizeScaleFactor const):

Tie the notion of "view scale" on iOS to layoutSizeScaleFactor. As its name suggests, this is a scale factor
by which we transform the layout size.

  • UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::setViewportConfigurationViewLayoutSize):

  • WebProcess/WebPage/WebPage.cpp:
  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:

Plumb the layout size scale factor over to the web process, along with the layout size.

  • WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::setViewportConfigurationViewLayoutSize):

Tools:

Teach UIScriptController to set WKWebView's view scale via a new setViewScale method, supported in WebKit2 on
macOS and iOS.

  • DumpRenderTree/ios/UIScriptControllerIOS.mm:

(WTR::UIScriptController::setViewScale):

  • DumpRenderTree/mac/UIScriptControllerMac.mm:

(WTR::UIScriptController::setViewScale):

  • TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl:
  • TestRunnerShared/UIScriptContext/UIScriptController.cpp:

(WTR::UIScriptController::setViewScale):

  • TestRunnerShared/UIScriptContext/UIScriptController.h:
  • WebKitTestRunner/UIScriptControllerCocoa.mm: Added.

Add a new file for UIScriptController methods on Cocoa platforms.

(WTR::UIScriptController::setViewScale):

  • WebKitTestRunner/WebKitTestRunner.xcodeproj/project.pbxproj:
  • WebKitTestRunner/cocoa/TestControllerCocoa.mm:

(WTR::TestController::cocoaResetStateToConsistentValues):

Ensure that _viewScale is reset to 1 after running a layout test.

LayoutTests:

Add two new layout tests on iOS that change WKWebView's view scale, and measure the resulting window sizes and
lengths of viewport units.

  • fast/viewport/ios/constant-width-viewport-after-changing-view-scale-expected.txt: Added.
  • fast/viewport/ios/constant-width-viewport-after-changing-view-scale.html: Added.

Add a test page with a viewport meta tag that has a constant width and an explicit initial scale of 0.5.

  • fast/viewport/ios/device-width-viewport-after-changing-view-scale-expected.txt: Added.
  • fast/viewport/ios/device-width-viewport-after-changing-view-scale.html: Added.

Add a test page with a viewport meta tag at device-width, with initial scale 1.

  • resources/ui-helper.js:

(window.UIHelper.setViewScale):

Add a convenience function that wraps a UI script invocation of setViewScale in a promise.

(window.UIHelper):

Location:
trunk
Files:
5 added
27 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r237072 r237087  
     12018-10-12  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [iOS] Allow SPI clients to lay out at arbitrarily scaled sizes and scale to fit the view
     4        https://bugs.webkit.org/show_bug.cgi?id=190504
     5        <rdar://problem/45117760>
     6
     7        Reviewed by Tim Horton.
     8
     9        Add two new layout tests on iOS that change WKWebView's view scale, and measure the resulting window sizes and
     10        lengths of viewport units.
     11
     12        * fast/viewport/ios/constant-width-viewport-after-changing-view-scale-expected.txt: Added.
     13        * fast/viewport/ios/constant-width-viewport-after-changing-view-scale.html: Added.
     14
     15        Add a test page with a viewport meta tag that has a constant width and an explicit initial scale of 0.5.
     16
     17        * fast/viewport/ios/device-width-viewport-after-changing-view-scale-expected.txt: Added.
     18        * fast/viewport/ios/device-width-viewport-after-changing-view-scale.html: Added.
     19
     20        Add a test page with a viewport meta tag at device-width, with initial scale 1.
     21
     22        * resources/ui-helper.js:
     23        (window.UIHelper.setViewScale):
     24
     25        Add a convenience function that wraps a UI script invocation of `setViewScale` in a promise.
     26
     27        (window.UIHelper):
     28
    1292018-10-12  Dawei Fenton  <realdawei@apple.com>
    230

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

    r237012 r237087  
    340340        });
    341341    }
     342
     343    static setViewScale(scale)
     344    {
     345        if (!this.isWebKit2())
     346            return Promise.resolve();
     347
     348        return new Promise(resolve => testRunner.runUIScript(`uiController.setViewScale(${scale})`, resolve));
     349    }
    342350}

  • trunk/Source/WebCore/ChangeLog

    r237082 r237087  
     12018-10-12  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [iOS] Allow SPI clients to lay out at arbitrarily scaled sizes and scale to fit the view
     4        https://bugs.webkit.org/show_bug.cgi?id=190504
     5        <rdar://problem/45117760>
     6
     7        Reviewed by Tim Horton.
     8
     9        Add support in ViewportConfiguration for applying a layout size scale factor to the viewport. See below for
     10        more details.
     11
     12        Tests: fast/viewport/ios/constant-width-viewport-after-changing-view-scale.html
     13               fast/viewport/ios/device-width-viewport-after-changing-view-scale.html
     14
     15        * page/ViewportConfiguration.cpp:
     16        (WebCore::ViewportConfiguration::setViewLayoutSize):
     17
     18        The viewport's layout size may now be changed alongside the layout size scale factor. If either of these two
     19        variables change, we recompute our minimum layout size and viewport configuration parameters.
     20
     21        (WebCore::ViewportConfiguration::shouldIgnoreHorizontalScalingConstraints const):
     22        (WebCore::ViewportConfiguration::nativeWebpageParameters):
     23        (WebCore::ViewportConfiguration::testingParameters):
     24        (WebCore::ViewportConfiguration::updateConfiguration):
     25
     26        Multiply the minimum scale, initial scale, and maximum scale by the layout size scale factor. This allows us to
     27        keep the document well-proportioned within the viewport, while still laying out at a different layout size.
     28
     29        (WebCore::ViewportConfiguration::updateMinimumLayoutSize):
     30
     31        Compute the minimum layout size by scaling the default layout size derived from our view's size.
     32
     33        (WebCore::ViewportConfiguration::layoutWidth const):
     34        (WebCore::ViewportConfiguration::layoutHeight const):
     35        * page/ViewportConfiguration.h:
     36
     37        Maintain the original initial scale, unaffected by the layout size scale factor. This is used when computing
     38        layout width and height to prevent scaling by the layout size scale factor twice when computing layout sizes.
     39
     40        (WebCore::ViewportConfiguration::description const):
     41
     42        Include the layout size scale factor in ViewportConfiguration's description string.
     43
     44        (WebCore::ViewportConfiguration::Parameters::operator== const):
     45        (WebCore::operator<<):
     46
    1472018-10-12  Youenn Fablet  <youenn@apple.com>
    248

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

    r236530 r237087  
    115115}
    116116
    117 bool ViewportConfiguration::setViewLayoutSize(const FloatSize& viewLayoutSize)
    118 {
    119     if (m_viewLayoutSize == viewLayoutSize)
    120         return false;
    121 
     117bool ViewportConfiguration::setViewLayoutSize(const FloatSize& viewLayoutSize, std::optional<double>&& scaleFactor)
     118{
     119    double newScaleFactor = scaleFactor.value_or(m_layoutSizeScaleFactor);
     120    if (m_viewLayoutSize == viewLayoutSize && m_layoutSizeScaleFactor == newScaleFactor)
     121        return false;
     122
     123    m_layoutSizeScaleFactor = newScaleFactor;
    122124    m_viewLayoutSize = viewLayoutSize;
    123125
    … …  
    192194        return laidOutWiderThanViewport;
    193195
    194     if (m_configuration.initialScaleIsSet && m_configuration.initialScale == 1)
     196    if (m_configuration.initialScaleIsSet && m_configuration.initialScaleIgnoringLayoutScaleFactor == 1)
    195197        return laidOutWiderThanViewport;
    196198
    … …  
    300302    parameters.maximumScale = 5;
    301303    parameters.initialScale = 1;
     304    parameters.initialScaleIgnoringLayoutScaleFactor = 1;
    302305    parameters.initialScaleIsSet = true;
    303306    return parameters;
    … …  
    358361    Parameters parameters;
    359362    parameters.initialScale = 1;
     363    parameters.initialScaleIgnoringLayoutScaleFactor = 1;
    360364    parameters.initialScaleIsSet = true;
    361365    parameters.allowsShrinkToFit = true;
    … …  
    427431
    428432    m_configuration.avoidsUnsafeArea = m_viewportArguments.viewportFit != ViewportFit::Cover;
     433    m_configuration.initialScaleIgnoringLayoutScaleFactor = m_configuration.initialScale;
     434    m_configuration.initialScale *= m_layoutSizeScaleFactor;
     435    m_configuration.minimumScale *= m_layoutSizeScaleFactor;
     436    m_configuration.maximumScale *= m_layoutSizeScaleFactor;
    429437
    430438    LOG_WITH_STREAM(Viewports, stream << "ViewportConfiguration " << this << " updateConfiguration " << *this << " gives initial scale " << initialScale() << " based on contentSize " << m_contentSize << " and layout size " << layoutWidth() << "x" << layoutHeight());
    … …  
    433441void ViewportConfiguration::updateMinimumLayoutSize()
    434442{
    435     if (!shouldOverrideDeviceWidthAndShrinkToFit()) {
    436         m_minimumLayoutSize = m_viewLayoutSize;
     443    m_minimumLayoutSize = m_viewLayoutSize / m_layoutSizeScaleFactor;
     444
     445    if (!shouldOverrideDeviceWidthAndShrinkToFit())
    437446        return;
    438     }
    439447
    440448    float minDeviceWidth = platformDeviceWidthOverride();
    441     m_minimumLayoutSize = FloatSize(minDeviceWidth, std::roundf(m_viewLayoutSize.height() * (minDeviceWidth / m_viewLayoutSize.width())));
     449    m_minimumLayoutSize = FloatSize(minDeviceWidth, std::roundf(m_minimumLayoutSize.height() * (minDeviceWidth / m_minimumLayoutSize.width())));
    442450}
    443451
    … …  
    470478
    471479        // If not, make sure the viewport width and initial scale can co-exist.
    472         double initialContentWidthInViewportCoordinate = m_configuration.width * m_configuration.initialScale;
     480        double initialContentWidthInViewportCoordinate = m_configuration.width * m_configuration.initialScaleIgnoringLayoutScaleFactor;
    473481        if (initialContentWidthInViewportCoordinate < minimumLayoutSize.width()) {
    474482            // The specified width does not fit in viewport. Return the minimum width that satisfy the initialScale constraint.
    475             return std::round(minimumLayoutSize.width() / m_configuration.initialScale);
     483            return std::round(minimumLayoutSize.width() / m_configuration.initialScaleIgnoringLayoutScaleFactor);
    476484        }
    477485        return std::round(m_configuration.width);
    … …  
    480488    // If the page has a real scale, then just return the minimum size over the initial scale.
    481489    if (m_configuration.initialScaleIsSet && !m_configuration.heightIsSet)
    482         return std::round(minimumLayoutSize.width() / m_configuration.initialScale);
     490        return std::round(minimumLayoutSize.width() / m_configuration.initialScaleIgnoringLayoutScaleFactor);
    483491
    484492    if (minimumLayoutSize.height() > 0)
    … …  
    506514
    507515        // If not, make sure the viewport width and initial scale can co-exist.
    508         double initialContentHeightInViewportCoordinate = m_configuration.height * m_configuration.initialScale;
     516        double initialContentHeightInViewportCoordinate = m_configuration.height * m_configuration.initialScaleIgnoringLayoutScaleFactor;
    509517        if (initialContentHeightInViewportCoordinate < minimumLayoutSize.height()) {
    510518            // The specified width does not fit in viewport. Return the minimum height that satisfy the initialScale constraint.
    511             return std::round(minimumLayoutSize.height() / m_configuration.initialScale);
     519            return std::round(minimumLayoutSize.height() / m_configuration.initialScaleIgnoringLayoutScaleFactor);
    512520        }
    513521        return std::round(m_configuration.height);
    … …  
    516524    // If the page has a real scale, then just return the minimum size over the initial scale.
    517525    if (m_configuration.initialScaleIsSet && !m_configuration.widthIsSet)
    518         return std::round(minimumLayoutSize.height() / m_configuration.initialScale);
     526        return std::round(minimumLayoutSize.height() / m_configuration.initialScaleIgnoringLayoutScaleFactor);
    519527
    520528    if (minimumLayoutSize.width() > 0)
    … …  
    539547    ts.endGroup();
    540548
     549    ts.dumpProperty("initialScaleIgnoringLayoutScaleFactor", parameters.initialScaleIgnoringLayoutScaleFactor);
    541550    ts.dumpProperty("minimumScale", parameters.minimumScale);
    542551    ts.dumpProperty("maximumScale", parameters.maximumScale);
    … …  
    577586    ts.dumpProperty("contentSize", m_contentSize);
    578587    ts.dumpProperty("minimumLayoutSize", m_minimumLayoutSize);
     588    ts.dumpProperty("layoutSizeScaleFactor", m_layoutSizeScaleFactor);
    579589    ts.dumpProperty("computed initial scale", initialScale());
    580590    ts.dumpProperty("computed minimum scale", minimumScale());

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

    r236530 r237087  
    5050        double height { 0 };
    5151        double initialScale { 0 };
     52        double initialScaleIgnoringLayoutScaleFactor { 0 };
    5253        double minimumScale { 0 };
    5354        double maximumScale { 0 };
    … …  
    6364        {
    6465            return width == other.width && height == other.height
    65                 && initialScale == other.initialScale && minimumScale == other.minimumScale && maximumScale == other.maximumScale
     66                && initialScale == other.initialScale && initialScaleIgnoringLayoutScaleFactor == other.initialScaleIgnoringLayoutScaleFactor && minimumScale == other.minimumScale && maximumScale == other.maximumScale
    6667                && allowsUserScaling == other.allowsUserScaling && allowsShrinkToFit == other.allowsShrinkToFit && avoidsUnsafeArea == other.avoidsUnsafeArea
    6768                && widthIsSet == other.widthIsSet && heightIsSet == other.heightIsSet && initialScaleIsSet == other.initialScaleIsSet;
    … …  
    8081
    8182    const FloatSize& minimumLayoutSize() const { return m_minimumLayoutSize; }
    82     WEBCORE_EXPORT bool setViewLayoutSize(const FloatSize&);
     83    WEBCORE_EXPORT bool setViewLayoutSize(const FloatSize&, std::optional<double>&& scaleFactor = std::nullopt);
    8384
    8485    const OptionSet<DisabledAdaptations>& disabledAdaptations() const { return m_disabledAdaptations; }
    … …  
    138139    OptionSet<DisabledAdaptations> m_disabledAdaptations;
    139140
     141    double m_layoutSizeScaleFactor { 1 };
    140142    bool m_canIgnoreScalingConstraints;
    141143    bool m_forceAlwaysUserScalable;

  • trunk/Source/WebKit/ChangeLog

    r237074 r237087  
     12018-10-12  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [iOS] Allow SPI clients to lay out at arbitrarily scaled sizes and scale to fit the view
     4        https://bugs.webkit.org/show_bug.cgi?id=190504
     5        <rdar://problem/45117760>
     6
     7        Reviewed by Tim Horton.
     8
     9        Add support for _setViewScale: and _viewScale on iOS. While similar in concept to macOS, changing this property
     10        on iOS uses viewport configurations to change the minimum layout size of the document and apply view scaling.
     11        Setting the view scale on iOS to a value `s` multiplies the minimium layout size by a factor `1 / s`, but also
     12        multiplies the initial, minimum and maximum scales by a factor of `s`. The net effect of applying this scale
     13        causes the page to lay out at a larger width and shrink (or a smaller width and expand) to fit the viewport.
     14
     15        * Shared/WebPageCreationParameters.cpp:
     16        (WebKit::WebPageCreationParameters::encode const):
     17        (WebKit::WebPageCreationParameters::decode):
     18        * Shared/WebPageCreationParameters.h:
     19
     20        Send `viewportConfigurationLayoutSizeScaleFactor` alongside `viewportConfigurationViewLayoutSize`.
     21
     22        (-[WKWebView _dispatchSetViewLayoutSize:]):
     23        (-[WKWebView _viewScale]):
     24        (-[WKWebView _setViewScale:]):
     25
     26        Provide a different implementation of `_setViewScale:` on iOS, by scaling the effective minimum layout size.
     27        (See above for more detail).
     28
     29        * UIProcess/API/Cocoa/WKWebViewPrivate.h:
     30
     31        Add missing API availability annotations for the _viewScale property.
     32
     33        * UIProcess/API/mac/WKView.mm:
     34        (-[WKView _setViewScale:]):
     35        * UIProcess/Cocoa/WebViewImpl.mm:
     36
     37        Both -[WKView _setViewScale:] and -[WKWebView _setViewScale:] throw Objective C exceptions upon receiving a bad
     38        argument (e.g. scale <= 0). However, logic for throwing this exception is specific to iOS in WKWebView, and
     39        handled in WebViewImpl on macOS. To make this less confusing, move the exception throwing code out of
     40        !PLATFORM(MAC) in WKWebView, and move the path for raising this exception in WKView on macOS from WebViewImpl to
     41        WKView.
     42
     43        * UIProcess/WebPageProxy.cpp:
     44        (WebKit::WebPageProxy::creationParameters):
     45        * UIProcess/WebPageProxy.h:
     46        (WebKit::WebPageProxy::layoutSizeScaleFactor const):
     47
     48        Tie the notion of "view scale" on iOS to `layoutSizeScaleFactor`. As its name suggests, this is a scale factor
     49        by which we transform the layout size.
     50
     51        * UIProcess/ios/WebPageProxyIOS.mm:
     52        (WebKit::WebPageProxy::setViewportConfigurationViewLayoutSize):
     53        * WebProcess/WebPage/WebPage.cpp:
     54        * WebProcess/WebPage/WebPage.h:
     55        * WebProcess/WebPage/WebPage.messages.in:
     56
     57        Plumb the layout size scale factor over to the web process, along with the layout size.
     58
     59        * WebProcess/WebPage/ios/WebPageIOS.mm:
     60        (WebKit::WebPage::setViewportConfigurationViewLayoutSize):
     61
    1622018-10-12  Alex Christensen  <achristensen@webkit.org>
    263

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

    r236865 r237087  
    9191    encoder << ignoresViewportScaleLimits;
    9292    encoder << viewportConfigurationViewLayoutSize;
     93    encoder << viewportConfigurationLayoutSizeScaleFactor;
    9394    encoder << viewportConfigurationViewSize;
    9495    encoder << maximumUnobscuredSize;
    … …  
    258259    if (!decoder.decode(parameters.viewportConfigurationViewLayoutSize))
    259260        return std::nullopt;
     261    if (!decoder.decode(parameters.viewportConfigurationLayoutSizeScaleFactor))
     262        return std::nullopt;
    260263    if (!decoder.decode(parameters.viewportConfigurationViewSize))
    261264        return std::nullopt;

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

    r236865 r237087  
    148148    bool ignoresViewportScaleLimits;
    149149    WebCore::FloatSize viewportConfigurationViewLayoutSize;
     150    double viewportConfigurationLayoutSizeScaleFactor;
    150151    WebCore::FloatSize viewportConfigurationViewSize;
    151152    WebCore::FloatSize maximumUnobscuredSize;

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

    r237055 r237087  
    26412641
    26422642    LOG_WITH_STREAM(VisibleRects, stream << "-[WKWebView " << _page->pageID() << " _dispatchSetViewLayoutSize:] " << viewLayoutSize << " contentZoomScale " << contentZoomScale(self));
    2643     _page->setViewportConfigurationViewLayoutSize(viewLayoutSize);
     2643    _page->setViewportConfigurationViewLayoutSize(viewLayoutSize, _page->layoutSizeScaleFactor());
    26442644    _lastSentViewLayoutSize = viewLayoutSize;
    26452645}
    … …  
    51515151- (CGFloat)_viewScale
    51525152{
     5153#if PLATFORM(MAC)
    51535154    return _page->viewScaleFactor();
     5155#else
     5156    return _page->layoutSizeScaleFactor();
     5157#endif
    51545158}
    51555159
    51565160- (void)_setViewScale:(CGFloat)viewScale
    51575161{
     5162    if (viewScale <= 0 || isnan(viewScale) || isinf(viewScale))
     5163        [NSException raise:NSInvalidArgumentException format:@"View scale should be a positive number"];
     5164
    51585165#if PLATFORM(MAC)
    51595166    _impl->setViewScale(viewScale);
    51605167#else
    5161     if (viewScale <= 0 || isnan(viewScale) || isinf(viewScale))
    5162         [NSException raise:NSInvalidArgumentException format:@"View scale should be a positive number"];
    5163 
    5164     _page->scaleView(viewScale);
     5168    if (_page->layoutSizeScaleFactor() == viewScale)
     5169        return;
     5170
     5171    _page->setViewportConfigurationViewLayoutSize([self activeViewLayoutSize:self.bounds], viewScale);
    51655172#endif
    51665173}

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

    r237012 r237087  
    178178@property (nonatomic, setter=_setViewportSizeForCSSViewportUnits:) CGSize _viewportSizeForCSSViewportUnits WK_API_AVAILABLE(macosx(10.13), ios(11.0));
    179179
    180 @property (nonatomic, setter=_setViewScale:) CGFloat _viewScale;
     180@property (nonatomic, setter=_setViewScale:) CGFloat _viewScale WK_API_AVAILABLE(macosx(10.11), ios(9.0));
    181181
    182182@property (nonatomic, setter=_setBackgroundExtendsBeyondPage:) BOOL _backgroundExtendsBeyondPage WK_API_AVAILABLE(macosx(10.13.4), ios(8.0));

  • trunk/Source/WebKit/UIProcess/API/mac/WKView.mm

    r236902 r237087  
    14311431- (void)_setViewScale:(CGFloat)viewScale
    14321432{
     1433    if (viewScale <= 0 || isnan(viewScale) || isinf(viewScale))
     1434        [NSException raise:NSInvalidArgumentException format:@"View scale should be a positive number"];
     1435
    14331436    _data->_impl->setViewScale(viewScale);
    14341437}

  • trunk/Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm

    r237012 r237087  
    18871887        return;
    18881888
    1889     if (viewScale <= 0 || isnan(viewScale) || isinf(viewScale))
    1890         [NSException raise:NSInvalidArgumentException format:@"View scale should be a positive number"];
    1891 
    18921889    m_page->scaleView(viewScale);
    18931890    [m_layoutStrategy didChangeViewScale];

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

    r237008 r237087  
    63406340    parameters.ignoresViewportScaleLimits = m_forceAlwaysUserScalable;
    63416341    parameters.viewportConfigurationViewLayoutSize = m_viewportConfigurationViewLayoutSize;
     6342    parameters.viewportConfigurationLayoutSizeScaleFactor = m_viewportConfigurationLayoutSizeScaleFactor;
    63426343    parameters.maximumUnobscuredSize = m_maximumUnobscuredSize;
    63436344#endif

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

    r237074 r237087  
    586586    void dynamicViewportSizeUpdate(const WebCore::FloatSize& viewLayoutSize, 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, DynamicViewportSizeUpdateID);
    587587
    588     void setViewportConfigurationViewLayoutSize(const WebCore::FloatSize&);
     588    void setViewportConfigurationViewLayoutSize(const WebCore::FloatSize&, double scaleFactor);
    589589    void setMaximumUnobscuredSize(const WebCore::FloatSize&);
    590590    void setDeviceOrientation(int32_t);
    … …  
    638638    void setForceAlwaysUserScalable(bool);
    639639    bool forceAlwaysUserScalable() const { return m_forceAlwaysUserScalable; }
     640    double layoutSizeScaleFactor() const { return m_viewportConfigurationLayoutSizeScaleFactor; }
    640641    void setIsScrollingOrZooming(bool);
    641642    void requestRectsForGranularityWithSelectionOffset(WebCore::TextGranularity, uint32_t offset, WTF::Function<void(const Vector<WebCore::SelectionRect>&, CallbackBase::Error)>&&);
    … …  
    22302231    bool m_forceAlwaysUserScalable { false };
    22312232    WebCore::FloatSize m_viewportConfigurationViewLayoutSize;
     2233    double m_viewportConfigurationLayoutSizeScaleFactor { 1 };
    22322234    WebCore::FloatSize m_maximumUnobscuredSize;
    22332235#endif

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

    r236865 r237087  
    319319}
    320320
    321 void WebPageProxy::setViewportConfigurationViewLayoutSize(const WebCore::FloatSize& size)
     321void WebPageProxy::setViewportConfigurationViewLayoutSize(const WebCore::FloatSize& size, double scaleFactor)
    322322{
    323323    m_viewportConfigurationViewLayoutSize = size;
     324    m_viewportConfigurationLayoutSizeScaleFactor = scaleFactor;
    324325
    325326    if (isValid())
    326         m_process->send(Messages::WebPage::SetViewportConfigurationViewLayoutSize(size), m_pageID);
     327        m_process->send(Messages::WebPage::SetViewportConfigurationViewLayoutSize(size, scaleFactor), m_pageID);
    327328}
    328329

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

    r237004 r237087  
    624624
    625625#if PLATFORM(IOS)
    626     setViewportConfigurationViewLayoutSize(parameters.viewportConfigurationViewLayoutSize);
     626    setViewportConfigurationViewLayoutSize(parameters.viewportConfigurationViewLayoutSize, parameters.viewportConfigurationLayoutSizeScaleFactor);
    627627    setMaximumUnobscuredSize(parameters.maximumUnobscuredSize);
    628628#endif

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

    r236867 r237087  
    894894
    895895#if PLATFORM(IOS)
    896     void setViewportConfigurationViewLayoutSize(const WebCore::FloatSize&);
     896    void setViewportConfigurationViewLayoutSize(const WebCore::FloatSize&, double scaleFactor);
    897897    void setMaximumUnobscuredSize(const WebCore::FloatSize&);
    898898    void setDeviceOrientation(int32_t);

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

    r237074 r237087  
    4646    MouseEvent(WebKit::WebMouseEvent event)
    4747#if PLATFORM(IOS)
    48     SetViewportConfigurationViewLayoutSize(WebCore::FloatSize size)
     48    SetViewportConfigurationViewLayoutSize(WebCore::FloatSize size, double scaleFactor)
    4949    SetMaximumUnobscuredSize(WebCore::FloatSize size)
    5050    SetDeviceOrientation(int32_t deviceOrientation)

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

    r236619 r237087  
    25192519}
    25202520
    2521 void WebPage::setViewportConfigurationViewLayoutSize(const FloatSize& size)
    2522 {
    2523     LOG_WITH_STREAM(VisibleRects, stream << "WebPage " << m_pageID << " setViewportConfigurationViewLayoutSize " << size);
    2524     if (m_viewportConfiguration.setViewLayoutSize(size))
     2521void WebPage::setViewportConfigurationViewLayoutSize(const FloatSize& size, double scaleFactor)
     2522{
     2523    LOG_WITH_STREAM(VisibleRects, stream << "WebPage " << m_pageID << " setViewportConfigurationViewLayoutSize " << size << " scaleFactor " << scaleFactor);
     2524    if (m_viewportConfiguration.setViewLayoutSize(size, scaleFactor))
    25252525        viewportConfigurationChanged();
    25262526}

  • trunk/Tools/ChangeLog

    r237083 r237087  
     12018-10-12  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        [iOS] Allow SPI clients to lay out at arbitrarily scaled sizes and scale to fit the view
     4        https://bugs.webkit.org/show_bug.cgi?id=190504
     5        <rdar://problem/45117760>
     6
     7        Reviewed by Tim Horton.
     8
     9        Teach UIScriptController to set WKWebView's view scale via a new `setViewScale` method, supported in WebKit2 on
     10        macOS and iOS.
     11
     12        * DumpRenderTree/ios/UIScriptControllerIOS.mm:
     13        (WTR::UIScriptController::setViewScale):
     14        * DumpRenderTree/mac/UIScriptControllerMac.mm:
     15        (WTR::UIScriptController::setViewScale):
     16        * TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl:
     17        * TestRunnerShared/UIScriptContext/UIScriptController.cpp:
     18        (WTR::UIScriptController::setViewScale):
     19        * TestRunnerShared/UIScriptContext/UIScriptController.h:
     20        * WebKitTestRunner/UIScriptControllerCocoa.mm: Added.
     21
     22        Add a new file for UIScriptController methods on Cocoa platforms.
     23
     24        (WTR::UIScriptController::setViewScale):
     25        * WebKitTestRunner/WebKitTestRunner.xcodeproj/project.pbxproj:
     26        * WebKitTestRunner/cocoa/TestControllerCocoa.mm:
     27        (WTR::TestController::cocoaResetStateToConsistentValues):
     28
     29        Ensure that _viewScale is reset to 1 after running a layout test.
     30
    1312018-10-12  Aakash Jain  <aakash_jain@apple.com>
    232

  • trunk/Tools/DumpRenderTree/ios/UIScriptControllerIOS.mm

    r237012 r237087  
    8383}
    8484
     85void UIScriptController::setViewScale(double)
     86{
     87}
     88
    8589void UIScriptController::simulateAccessibilitySettingsChangeNotification(JSValueRef)
    8690{

  • trunk/Tools/DumpRenderTree/mac/UIScriptControllerMac.mm

    r237012 r237087  
    8888        m_context->asyncTaskComplete(callbackID);
    8989    });
     90}
     91
     92void UIScriptController::setViewScale(double)
     93{
    9094}
    9195

  • trunk/Tools/TestRunnerShared/UIScriptContext/Bindings/UIScriptController.idl

    r237012 r237087  
    217217    void zoomToScale(double scale, object callback);
    218218
     219    void setViewScale(double scale);
     220
    219221    void scrollToOffset(long x, long y); // Initiate an animated scroll in the UI process.
    220222    attribute object didEndScrollingCallback;

  • trunk/Tools/TestRunnerShared/UIScriptContext/UIScriptController.cpp

    r237012 r237087  
    211211}
    212212
     213void UIScriptController::setViewScale(double)
     214{
     215}
     216
    213217void UIScriptController::simulateAccessibilitySettingsChangeNotification(JSValueRef)
    214218{

  • trunk/Tools/TestRunnerShared/UIScriptContext/UIScriptController.h

    r237012 r237087  
    6767
    6868    void zoomToScale(double scale, JSValueRef callback);
     69    void setViewScale(double);
    6970
    7071    void simulateAccessibilitySettingsChangeNotification(JSValueRef callback);

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

    r236913 r237087  
    136136                E1C642C317CBCC7300D66A3C /* PoseAsClass.mm in Sources */ = {isa = PBXBuildFile; fileRef = E1C642C117CBCC7300D66A3C /* PoseAsClass.mm */; };
    137137                E1C642C617CBCD4C00D66A3C /* WebKitTestRunnerPasteboard.mm in Sources */ = {isa = PBXBuildFile; fileRef = E1C642C417CBCD4C00D66A3C /* WebKitTestRunnerPasteboard.mm */; };
     138                F46240B1217013E500917B16 /* UIScriptControllerCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = F46240AF2170128300917B16 /* UIScriptControllerCocoa.mm */; };
    138139                F4C3578C20E8444600FA0748 /* LayoutTestSpellChecker.mm in Sources */ = {isa = PBXBuildFile; fileRef = F4C3578A20E8444000FA0748 /* LayoutTestSpellChecker.mm */; };
    139140/* End PBXBuildFile section */
    … …  
    379380                E1C642C417CBCD4C00D66A3C /* WebKitTestRunnerPasteboard.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = WebKitTestRunnerPasteboard.mm; sourceTree = "<group>"; };
    380381                E1C642C517CBCD4C00D66A3C /* WebKitTestRunnerPasteboard.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebKitTestRunnerPasteboard.h; sourceTree = "<group>"; };
     382                F46240AF2170128300917B16 /* UIScriptControllerCocoa.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = UIScriptControllerCocoa.mm; sourceTree = "<group>"; };
    381383                F4C3578A20E8444000FA0748 /* LayoutTestSpellChecker.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; name = LayoutTestSpellChecker.mm; path = ../TestRunnerShared/cocoa/LayoutTestSpellChecker.mm; sourceTree = "<group>"; };
    382384                F4C3578B20E8444000FA0748 /* LayoutTestSpellChecker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LayoutTestSpellChecker.h; path = ../TestRunnerShared/cocoa/LayoutTestSpellChecker.h; sourceTree = "<group>"; };
    … …  
    557559                                0F87B6141BACC4B9004EC572 /* TestRunnerWKWebView.h */,
    558560                                0F87B6151BACC4B9004EC572 /* TestRunnerWKWebView.mm */,
     561                                F46240AF2170128300917B16 /* UIScriptControllerCocoa.mm */,
    559562                        );
    560563                        name = cocoa;
    … …  
    10831086                                0F18E6E51D6B9B9E0027E547 /* UIScriptContext.cpp in Sources */,
    10841087                                0F18E6E61D6B9BA20027E547 /* UIScriptController.cpp in Sources */,
     1088                                F46240B1217013E500917B16 /* UIScriptControllerCocoa.mm in Sources */,
    10851089                                0F73B55C1BA89042004B3EF4 /* UIScriptControllerIOS.mm in Sources */,
    10861090                                A18510431B9AE14500744AEB /* WebNotificationProvider.cpp in Sources */,

  • trunk/Tools/WebKitTestRunner/cocoa/TestControllerCocoa.mm

    r236481 r237087  
    216216    [[_WKUserContentExtensionStore defaultStore] _removeAllContentExtensions];
    217217
    218     if (PlatformWebView* webView = mainWebView())
    219         [webView->platformView().configuration.userContentController _removeAllUserContentFilters];
     218    if (auto* webView = mainWebView()) {
     219        TestRunnerWKWebView *platformView = webView->platformView();
     220        [platformView.configuration.userContentController _removeAllUserContentFilters];
     221        platformView._viewScale = 1;
     222    }
    220223#endif
    221224}
Note: See TracChangeset for help on using the changeset viewer.