Changeset 255054 in webkit

Timestamp:

Jan 23, 2020 9:55:54 PM (4 years ago)

Author:

Wenson Hsieh

Message:

[iOS] Support setting minimum effective device width during dynamic viewport size updates
​https://bugs.webkit.org/show_bug.cgi?id=206709
<rdar://problem/58713872>

Reviewed by Tim Horton.

Source/WebKit:

Changes to minimum effective device width are currently always propagated to the web process via out-of-band
updates to the web process. During animated resize, Safari currently changes the minimum effective device width
prior to updating the view size; this causes the viewport configuration to temporarily be in a state where the
new value for minimum effective device width is used, but the old viewport width and height are still used.

This subsequently breaks existing logic in WebPage::dynamicViewportSizeUpdate that attempts to keep the portion
of the unobscured content width that is visible consistent before and after rotation (see
visibleHorizontalFraction), since that code will be mislead into believing that the wrong fraction of content
width is visible.

To fix this, we roll minimum effective device width changes along with view size (and other attributes) in
dynamic viewport size updates.

Test: WebKit.ChangeFrameAndMinimumEffectiveDeviceWidthDuringAnimatedResize

• UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView _setViewScale:]):
(-[WKWebView _setMinimumEffectiveDeviceWidth:]):

During animated resize, just set m_minimumEffectiveDeviceWidth without notifying the web process; if the value
changed during the update block, we send the new minimum effective device width to the web page as a part of
the dynamic viewport size update.

Also, make a drive-by adjustment to use _page->viewLayoutSize() instead of recomputing the active layout
bounds when we know that only the minimum effective device width is changing. We also apply the same adjustment
above, in -_setViewScale:.

• UIProcess/API/ios/WKWebViewIOS.mm:

(-[WKWebView _beginAnimatedResizeWithUpdates:]):

• UIProcess/WebPageProxy.h:

(WebKit::WebPageProxy::viewLayoutSize const):
(WebKit::WebPageProxy::setMinimumEffectiveDeviceWidthWithoutViewportConfigurationUpdate):

Add a helper method to update the minimum effective device width without updating the viewport configuration in
the web process. This is only used when the minimum effective device width is specified in the middle of a
dynamic viewport size update (i.e. animated resize).

• UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::dynamicViewportSizeUpdate):

Plumb the new minimum effective device width over to the web process as a part of the dynamic viewport size
update, and update both the new view size and minimum effective device width on the viewport configuration at
the same time.

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

(WebKit::WebPage::dynamicViewportSizeUpdate):

Tools:

Adds a new API test that changes both the effective minimum device width and view size during animated resize.

• TestWebKitAPI/Tests/WebKitCocoa/AnimatedResize.mm:

Location:

trunk

Files:

• Source/WebKit/ChangeLog (modified) (1 diff)
• Source/WebKit/UIProcess/API/Cocoa/WKWebView.mm (modified) (2 diffs)
• Source/WebKit/UIProcess/API/ios/WKWebViewIOS.mm (modified) (4 diffs)
• Source/WebKit/UIProcess/WebPageProxy.h (modified) (2 diffs)
• Source/WebKit/UIProcess/ios/WebPageProxyIOS.mm (modified) (2 diffs)
• Source/WebKit/WebProcess/WebPage/WebPage.h (modified) (1 diff)
• Source/WebKit/WebProcess/WebPage/WebPage.messages.in (modified) (1 diff)
• Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm (modified) (2 diffs)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WebKitCocoa/AnimatedResize.mm (modified) (2 diffs)

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2020-01-23  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOS] Support setting minimum effective device width during dynamic viewport size updates
+        https://bugs.webkit.org/show_bug.cgi?id=206709
+        <rdar://problem/58713872>
+
+        Reviewed by Tim Horton.
+
+        Changes to minimum effective device width are currently always propagated to the web process via out-of-band
+        updates to the web process. During animated resize, Safari currently changes the minimum effective device width
+        prior to updating the view size; this causes the viewport configuration to temporarily be in a state where the
+        new value for minimum effective device width is used, but the old viewport width and height are still used.
+
+        This subsequently breaks existing logic in WebPage::dynamicViewportSizeUpdate that attempts to keep the portion
+        of the unobscured content width that is visible consistent before and after rotation (see
+        visibleHorizontalFraction), since that code will be mislead into believing that the wrong fraction of content
+        width is visible.
+
+        To fix this, we roll minimum effective device width changes along with view size (and other attributes) in
+        dynamic viewport size updates.
+
+        Test: WebKit.ChangeFrameAndMinimumEffectiveDeviceWidthDuringAnimatedResize
+
+        * UIProcess/API/Cocoa/WKWebView.mm:
+        (-[WKWebView _setViewScale:]):
+        (-[WKWebView _setMinimumEffectiveDeviceWidth:]):
+
+        During animated resize, just set m_minimumEffectiveDeviceWidth without notifying the web process; if the value
+        changed during the update block, we send the new minimum effective device width to the web page as a part of
+        the dynamic viewport size update.
+
+        Also, make a drive-by adjustment to use `_page->viewLayoutSize()` instead of recomputing the active layout
+        bounds when we know that only the minimum effective device width is changing. We also apply the same adjustment
+        above, in -_setViewScale:.
+
+        * UIProcess/API/ios/WKWebViewIOS.mm:
+        (-[WKWebView _beginAnimatedResizeWithUpdates:]):
+        * UIProcess/WebPageProxy.h:
+        (WebKit::WebPageProxy::viewLayoutSize const):
+        (WebKit::WebPageProxy::setMinimumEffectiveDeviceWidthWithoutViewportConfigurationUpdate):
+
+        Add a helper method to update the minimum effective device width without updating the viewport configuration in
+        the web process. This is only used when the minimum effective device width is specified in the middle of a
+        dynamic viewport size update (i.e. animated resize).
+
+        * UIProcess/ios/WebPageProxyIOS.mm:
+        (WebKit::WebPageProxy::dynamicViewportSizeUpdate):
+
+        Plumb the new minimum effective device width over to the web process as a part of the dynamic viewport size
+        update, and update both the new view size and minimum effective device width on the viewport configuration at
+        the same time.
+
+        * WebProcess/WebPage/WebPage.h:
+        * WebProcess/WebPage/WebPage.messages.in:
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::dynamicViewportSizeUpdate):
+
 2020-01-23  Per Arne Vollan  <pvollan@apple.com>
 

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

@@ -2707 +2707 @@
         return;
 
-    _page->setViewportConfigurationViewLayoutSize([self activeViewLayoutSize:self.bounds], viewScale, _page->minimumEffectiveDeviceWidth());
+    _page->setViewportConfigurationViewLayoutSize(_page->viewLayoutSize(), viewScale, _page->minimumEffectiveDeviceWidth());
 #endif
 }
@@ -2717 +2717 @@
         return;
 
-    _page->setViewportConfigurationViewLayoutSize([self activeViewLayoutSize:self.bounds], _page->layoutSizeScaleFactor(), minimumEffectiveDeviceWidth);
+    if (_dynamicViewportUpdateMode == WebKit::DynamicViewportUpdateMode::NotResizing)
+        _page->setViewportConfigurationViewLayoutSize(_page->viewLayoutSize(), _page->layoutSizeScaleFactor(), minimumEffectiveDeviceWidth);
+    else
+        _page->setMinimumEffectiveDeviceWidthWithoutViewportConfigurationUpdate(minimumEffectiveDeviceWidth);
 #endif
 }

trunk/Source/WebKit/UIProcess/API/ios/WKWebViewIOS.mm

@@ -2712 +2712 @@
     _dynamicViewportUpdateMode = WebKit::DynamicViewportUpdateMode::ResizingWithAnimation;
 
+    auto oldMinimumEffectiveDeviceWidth = [self _minimumEffectiveDeviceWidth];
     auto oldViewLayoutSize = [self activeViewLayoutSize:self.bounds];
     auto oldMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, oldBounds);
@@ -2720 +2721 @@
 
     CGRect newBounds = self.bounds;
+    auto newMinimumEffectiveDeviceWidth = [self _minimumEffectiveDeviceWidth];
     auto newViewLayoutSize = [self activeViewLayoutSize:newBounds];
     auto newMaximumUnobscuredSize = activeMaximumUnobscuredSize(self, newBounds);
@@ -2745 +2747 @@
         && oldMaximumUnobscuredSize == newMaximumUnobscuredSize
         && oldOrientation == newOrientation
+        && oldMinimumEffectiveDeviceWidth == newMinimumEffectiveDeviceWidth
         && UIEdgeInsetsEqualToEdgeInsets(oldObscuredInsets, newObscuredInsets)) {
         [self _cancelAnimatedResize];
@@ -2812 +2815 @@
     _lastSentDeviceOrientation = newOrientation;
 
-    _page->dynamicViewportSizeUpdate(newViewLayoutSize, newMaximumUnobscuredSize, visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, futureUnobscuredRectInSelfCoordinates, unobscuredSafeAreaInsetsExtent, targetScale, newOrientation, ++_currentDynamicViewportSizeUpdateID);
+    _page->dynamicViewportSizeUpdate(newViewLayoutSize, newMaximumUnobscuredSize, visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, futureUnobscuredRectInSelfCoordinates, unobscuredSafeAreaInsetsExtent, targetScale, newOrientation, newMinimumEffectiveDeviceWidth, ++_currentDynamicViewportSizeUpdateID);
     if (WebKit::DrawingAreaProxy* drawingArea = _page->drawingArea())
         drawingArea->setSize(WebCore::IntSize(newBounds.size));

trunk/Source/WebKit/UIProcess/WebPageProxy.h

@@ -715 +715 @@
     void scrollingNodeScrollDidEndScroll();
 
-    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);
+    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, double minimumEffectiveDeviceWidth, DynamicViewportSizeUpdateID);
 
     void setViewportConfigurationViewLayoutSize(const WebCore::FloatSize&, double scaleFactor, double minimumEffectiveDeviceWidth);
@@ -776 +776 @@
     bool forceAlwaysUserScalable() const { return m_forceAlwaysUserScalable; }
     double layoutSizeScaleFactor() const { return m_viewportConfigurationLayoutSizeScaleFactor; }
+    WebCore::FloatSize viewLayoutSize() const { return m_viewportConfigurationViewLayoutSize; }
     double minimumEffectiveDeviceWidth() const { return m_viewportConfigurationMinimumEffectiveDeviceWidth; }
+    void setMinimumEffectiveDeviceWidthWithoutViewportConfigurationUpdate(double minimumEffectiveDeviceWidth) { m_viewportConfigurationMinimumEffectiveDeviceWidth = minimumEffectiveDeviceWidth; }
     void setIsScrollingOrZooming(bool);
     void requestRectsForGranularityWithSelectionOffset(WebCore::TextGranularity, uint32_t offset, WTF::Function<void(const Vector<WebCore::SelectionRect>&, CallbackBase::Error)>&&);

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

@@ -313 +313 @@
 }
 
-void WebPageProxy::dynamicViewportSizeUpdate(const FloatSize& viewLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation, DynamicViewportSizeUpdateID dynamicViewportSizeUpdateID)
+void WebPageProxy::dynamicViewportSizeUpdate(const FloatSize& viewLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& unobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation, double minimumEffectiveDeviceWidth, DynamicViewportSizeUpdateID dynamicViewportSizeUpdateID)
 {
     if (!hasRunningProcess())
@@ -324 +324 @@
         maximumUnobscuredSize, targetExposedContentRect, targetUnobscuredRect,
         targetUnobscuredRectInScrollViewCoordinates, unobscuredSafeAreaInsets,
-        targetScale, deviceOrientation, dynamicViewportSizeUpdateID), m_webPageID);
+        targetScale, deviceOrientation, minimumEffectiveDeviceWidth, dynamicViewportSizeUpdateID), m_webPageID);
 }
 

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

@@ -971 +971 @@
     void setMaximumUnobscuredSize(const WebCore::FloatSize&);
     void setDeviceOrientation(int32_t);
-    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& targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, DynamicViewportSizeUpdateID);
+    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& targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, double minimumEffectiveDeviceWidth, DynamicViewportSizeUpdateID);
     bool scaleWasSetByUIProcess() const { return m_scaleWasSetByUIProcess; }
     void willStartUserTriggeredZooming();

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

@@ -52 +52 @@
     SetDeviceOrientation(int32_t deviceOrientation)
     SetOverrideViewportArguments(Optional<WebCore::ViewportArguments> arguments)
-    DynamicViewportSizeUpdate(WebCore::FloatSize viewLayoutSize, WebCore::FloatSize maximumUnobscuredSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, WebCore::FloatRect targetUnobscuredRectInScrollViewCoordinates, WebCore::RectEdges<float> targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, uint64_t dynamicViewportSizeUpdateID)
+    DynamicViewportSizeUpdate(WebCore::FloatSize viewLayoutSize, WebCore::FloatSize maximumUnobscuredSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, WebCore::FloatRect targetUnobscuredRectInScrollViewCoordinates, WebCore::RectEdges<float> targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, double minimumEffectiveDeviceWidth, uint64_t dynamicViewportSizeUpdateID)
 
     HandleTap(WebCore::IntPoint point, OptionSet<WebKit::WebEvent::Modifier> modifiers, WebKit::TransactionID lastLayerTreeTransactionId)

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

@@ -3166 +3166 @@
 }
 
-void WebPage::dynamicViewportSizeUpdate(const FloatSize& viewLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& targetUnobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation, DynamicViewportSizeUpdateID dynamicViewportSizeUpdateID)
+void WebPage::dynamicViewportSizeUpdate(const FloatSize& viewLayoutSize, const WebCore::FloatSize& maximumUnobscuredSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, const WebCore::FloatRect& targetUnobscuredRectInScrollViewCoordinates, const WebCore::FloatBoxExtent& targetUnobscuredSafeAreaInsets, double targetScale, int32_t deviceOrientation, double minimumEffectiveDeviceWidth, DynamicViewportSizeUpdateID dynamicViewportSizeUpdateID)
 {
     SetForScope<bool> dynamicSizeUpdateGuard(m_inDynamicSizeUpdate, true);
@@ -3205 +3205 @@
     LOG_WITH_STREAM(VisibleRects, stream << "WebPage::dynamicViewportSizeUpdate setting view layout size to " << viewLayoutSize);
     bool viewportChanged = m_viewportConfiguration.setIsKnownToLayOutWiderThanViewport(false);
-    viewportChanged |= m_viewportConfiguration.setViewLayoutSize(viewLayoutSize);
+    viewportChanged |= m_viewportConfiguration.setViewLayoutSize(viewLayoutSize, WTF::nullopt, minimumEffectiveDeviceWidth);
     if (viewportChanged)
         viewportConfigurationChanged();

trunk/Tools/ChangeLog

@@ +1 @@
+2020-01-23  Wenson Hsieh  <wenson_hsieh@apple.com>
+
+        [iOS] Support setting minimum effective device width during dynamic viewport size updates
+        https://bugs.webkit.org/show_bug.cgi?id=206709
+        <rdar://problem/58713872>
+
+        Reviewed by Tim Horton.
+
+        Adds a new API test that changes both the effective minimum device width and view size during animated resize.
+
+        * TestWebKitAPI/Tests/WebKitCocoa/AnimatedResize.mm:
+
 2020-01-23  Per Arne Vollan  <pvollan@apple.com>
 

trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/AnimatedResize.mm

@@ -31 +31 @@
 #import "TestWKWebView.h"
 #import <WebKit/WKPreferences.h>
+#import <WebKit/WKPreferencesPrivate.h>
 #import <WebKit/WKProcessPoolPrivate.h>
 #import <WebKit/WKWebView.h>
@@ -288 +289 @@
         didReadLayoutSize = true;
     }];
+    TestWebKitAPI::Util::run(&didReadLayoutSize);
+}
+
+TEST(WebKit, ChangeFrameAndMinimumEffectiveDeviceWidthDuringAnimatedResize)
+{
+    auto webView = createAnimatedResizeWebView();
+    [[webView configuration] preferences]._shouldIgnoreMetaViewport = YES;
+    [webView setUIDelegate:webView.get()];
+    [webView loadHTMLString:@"<body>Hello world</body>" baseURL:nil];
+
+    auto navigationDelegate = adoptNS([[TestNavigationDelegate alloc] init]);
+    [webView setNavigationDelegate:navigationDelegate.get()];
+    [navigationDelegate waitForDidFinishNavigation];
+
+    auto window = adoptNS([[UIWindow alloc] initWithFrame:CGRectMake(0, 0, 800, 600)]);
+    [window addSubview:webView.get()];
+    [window setHidden:NO];
+
+    [webView _beginAnimatedResizeWithUpdates:^{
+        [webView _setMinimumEffectiveDeviceWidth:1000];
+        [webView setFrame:CGRectMake(0, 0, 500, 375)];
+    }];
+
+    [webView _endAnimatedResize];
+
+    __block bool didReadLayoutSize = false;
+    [webView _doAfterNextPresentationUpdate:^{
+        [webView evaluateJavaScript:@"[window.innerWidth, window.innerHeight, visualViewport.scale]" completionHandler:^(NSArray<NSNumber *> *value, NSError *error) {
+            CGFloat innerWidth = value[0].floatValue;
+            CGFloat innerHeight = value[1].floatValue;
+            CGFloat scale = value[2].floatValue;
+            EXPECT_EQ(innerWidth, 1000);
+            EXPECT_EQ(innerHeight, 750);
+            EXPECT_EQ(scale, 0.5);
+            didReadLayoutSize = true;
+        }];
+    }];
+
     TestWebKitAPI::Util::run(&didReadLayoutSize);
 }