Changeset 167614 in webkit

Timestamp:

Apr 21, 2014 1:10:12 PM (10 years ago)

Author:

benjamin@webkit.org

Message:

[iOS][WK2] Make dynamic viewport size update content aware
​https://bugs.webkit.org/show_bug.cgi?id=131874

Patch by Benjamin Poulain <​bpoulain@apple.com> on 2014-04-21
Reviewed by Tim Horton.

When possible, adjust the scroll position based on the content on dynamic viewport resize.

• WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::WebPage):
(WebKit::WebPage::scalePage):
(WebKit::WebPage::pageDidScroll):

• WebProcess/WebPage/WebPage.h:

The scrolling heuristic are not invertible, especially the content heuristic. To have the right
behavior when doing resize without changing the page, we save the old scroll position and restore
it when the content size and scale is restored.

• WebProcess/WebPage/ios/WebPageIOS.mm:

(WebKit::WebPage::dynamicViewportSizeUpdate):
On dynamic update, start by finding what node is at the center of the screen. After the layout, put that
node back in the center.

(WebKit::WebPage::updateVisibleContentRects):

Location:

trunk/Source/WebKit2

Files:

• ChangeLog (modified) (1 diff)
• WebProcess/WebPage/WebPage.cpp (modified) (3 diffs)
• WebProcess/WebPage/WebPage.h (modified) (2 diffs)
• WebProcess/WebPage/ios/WebPageIOS.mm (modified) (8 diffs)

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2014-04-21  Benjamin Poulain  <bpoulain@apple.com>
+
+        [iOS][WK2] Make dynamic viewport size update content aware
+        https://bugs.webkit.org/show_bug.cgi?id=131874
+
+        Reviewed by Tim Horton.
+
+        When possible, adjust the scroll position based on the content on dynamic viewport resize.
+
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::WebPage):
+        (WebKit::WebPage::scalePage):
+        (WebKit::WebPage::pageDidScroll):
+        * WebProcess/WebPage/WebPage.h:
+        The scrolling heuristic are not invertible, especially the content heuristic. To have the right
+        behavior when doing resize without changing the page, we save the old scroll position and restore
+        it when the content size and scale is restored.
+
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::dynamicViewportSizeUpdate):
+        On dynamic update, start by finding what node is at the center of the screen. After the layout, put that
+        node back in the center.
+
+        (WebKit::WebPage::updateVisibleContentRects):
+
 2014-04-21  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

@@ -289 +289 @@
     , m_screenSize(parameters.screenSize)
     , m_availableScreenSize(parameters.availableScreenSize)
+    , m_inDynamicSizeUpdate(false)
 #endif
     , m_inspectorClient(0)
@@ -1287 +1288 @@
 
 #if PLATFORM(IOS)
+    if (!m_inDynamicSizeUpdate)
+        m_dynamicSizeUpdateHistory.clear();
     m_scaleWasSetByUIProcess = false;
 #endif
@@ -1621 +1624 @@
 void WebPage::pageDidScroll()
 {
+#if PLATFORM(IOS)
+    if (!m_inDynamicSizeUpdate)
+        m_dynamicSizeUpdateHistory.clear();
+#endif
     m_uiClient->pageDidScroll(this);
 

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

@@ -51 +51 @@
 #include <WebCore/FrameLoaderTypes.h>
 #include <WebCore/IntRect.h>
+#include <WebCore/IntSizeHash.h>
 #include <WebCore/Page.h>
 #include <WebCore/PageVisibilityState.h>
@@ -1160 +1161 @@
     WebCore::FloatSize m_availableScreenSize;
     WebCore::IntSize m_blockSelectionDesiredSize;
+    bool m_inDynamicSizeUpdate;
+    HashMap<std::pair<WebCore::IntSize, double>, WebCore::IntPoint> m_dynamicSizeUpdateHistory;
 #endif
 

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

@@ -76 +76 @@
 #import <WebCore/RenderBlock.h>
 #import <WebCore/RenderImage.h>
+#import <WebCore/RenderView.h>
 #import <WebCore/ResourceBuffer.h>
 #import <WebCore/SharedBuffer.h>
@@ -82 +83 @@
 #import <WebCore/WKContentObservation.h>
 #import <WebCore/WebEvent.h>
+#import <wtf/TemporaryChange.h>
 
 using namespace WebCore;
@@ -1765 +1767 @@
 void WebPage::dynamicViewportSizeUpdate(const IntSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
 {
+    TemporaryChange<bool> dynamicSizeUpdateGuard(m_inDynamicSizeUpdate, true);
     // FIXME: this does not handle the cases where the content would change the content size or scroll position from JavaScript.
     // To handle those cases, we would need to redo this computation on every change until the next visible content rect update.
@@ -1770 +1773 @@
     FrameView& frameView = *m_page->mainFrame().view();
     IntSize oldContentSize = frameView.contentsSize();
+    float oldPageScaleFactor = m_page->pageScaleFactor();
+
+    m_dynamicSizeUpdateHistory.add(std::make_pair(oldContentSize, oldPageScaleFactor), IntPoint(frameView.scrollOffset()));
+
+    RefPtr<Node> oldNodeAtCenter;
+    float relativeHorizontalPositionInNodeAtCenter = 0;
+    float relativeVerticalPositionInNodeAtCenter = 0;
+    {
+        IntRect unobscuredContentRect = frameView.unobscuredContentRect();
+        IntPoint unobscuredContentRectCenter = unobscuredContentRect.center();
+
+        HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
+        HitTestResult hitTestResult = HitTestResult(unobscuredContentRectCenter);
+
+        RenderView* mainFrameRenderView = frameView.renderView();
+        mainFrameRenderView->hitTest(request, hitTestResult);
+
+        if (Node* node = hitTestResult.innerNode()) {
+            if (RenderObject* renderer = node->renderer()) {
+                FrameView& containingView = *node->document().frame()->view();
+                FloatRect boundingBox = containingView.contentsToRootView(renderer->absoluteBoundingBoxRect(true));
+                relativeHorizontalPositionInNodeAtCenter = (unobscuredContentRectCenter.x() - boundingBox.x()) / boundingBox.width();
+                relativeVerticalPositionInNodeAtCenter = (unobscuredContentRectCenter.y() - boundingBox.y()) / boundingBox.height();
+                oldNodeAtCenter = node;
+            }
+        }
+    }
 
     m_viewportConfiguration.setMinimumLayoutSize(minimumLayoutSize);
@@ -1808 +1838 @@
                                           newUnobscuredRectWidth + obscuredLeftMargin + obscuredRightMargin,
                                           newUnobscuredRectHeight + obscuredTopMargin + obscuredBottomMargin);
-
-        // FIXME: Adjust the rects based on the content.
     }
 
     if (oldContentSize != newContentSize || scale != targetScale) {
         // Snap the new unobscured rect back into the content rect.
-        newUnobscuredContentRect.setWidth(std::min(static_cast<float>(newContentSize.width()), newExposedContentRect.width()));
-        newUnobscuredContentRect.setHeight(std::min(static_cast<float>(newContentSize.height()), newExposedContentRect.height()));
-
-        if (oldContentSize != newContentSize) {
-            // If the content size has changed, keep the same relative position.
-            FloatPoint oldContentCenter = targetUnobscuredRect.center();
-            float relativeHorizontalPosition = oldContentCenter.x() / oldContentSize.width();
-            float relativeVerticalPosition =  oldContentCenter.y() / oldContentSize.height();
-            FloatPoint newRelativeContentCenter(relativeHorizontalPosition * newContentSize.width(), relativeVerticalPosition * newContentSize.height());
+        newUnobscuredContentRect.setWidth(std::min(static_cast<float>(newContentSize.width()), newUnobscuredContentRect.width()));
+        newUnobscuredContentRect.setHeight(std::min(static_cast<float>(newContentSize.height()), newUnobscuredContentRect.height()));
+
+        const auto& previousPosition = m_dynamicSizeUpdateHistory.find(std::pair<IntSize, float>(newContentSize, scale));
+        if (previousPosition != m_dynamicSizeUpdateHistory.end()) {
+            IntPoint restoredPosition = previousPosition->value;
+            FloatPoint deltaPosition(restoredPosition.x() - newUnobscuredContentRect.x(), restoredPosition.y() - newUnobscuredContentRect.y());
+            newUnobscuredContentRect.moveBy(deltaPosition);
+            newExposedContentRect.moveBy(deltaPosition);
+        } else if (oldContentSize != newContentSize) {
+            FloatPoint newRelativeContentCenter;
+
+            if (RenderObject* renderer = oldNodeAtCenter ? oldNodeAtCenter->renderer() : nullptr) {
+                FrameView& containingView = *oldNodeAtCenter->document().frame()->view();
+                FloatRect newBoundingBox = containingView.contentsToRootView(renderer->absoluteBoundingBoxRect(true));
+                newRelativeContentCenter = FloatPoint(newBoundingBox.x() + relativeHorizontalPositionInNodeAtCenter * newBoundingBox.width(), newBoundingBox.y() + relativeVerticalPositionInNodeAtCenter * newBoundingBox.height());
+            } else {
+                // If the content size has changed, keep the same relative position.
+                FloatPoint oldContentCenter = targetUnobscuredRect.center();
+                float relativeHorizontalPosition = oldContentCenter.x() / oldContentSize.width();
+                float relativeVerticalPosition =  oldContentCenter.y() / oldContentSize.height();
+                newRelativeContentCenter = FloatPoint(relativeHorizontalPosition * newContentSize.width(), relativeVerticalPosition * newContentSize.height());
+            }
+
             FloatPoint newUnobscuredContentRectCenter = newUnobscuredContentRect.center();
             FloatPoint positionDelta(newRelativeContentCenter.x() - newUnobscuredContentRectCenter.x(), newRelativeContentCenter.y() - newUnobscuredContentRectCenter.y());
@@ -1864 +1907 @@
 
     if (scale == targetScale)
-        scalePage(scale, frameView.scrollPosition());
+        scalePage(scale, roundedUnobscuredContentRect.location());
 
     if (scale != targetScale || roundedIntPoint(targetUnobscuredRect.location()) != roundedUnobscuredContentRect.location())
-        send(Messages::WebPageProxy::DynamicViewportUpdateChangedTarget(scale, frameView.scrollPosition()));
+        send(Messages::WebPageProxy::DynamicViewportUpdateChangedTarget(scale, roundedUnobscuredContentRect.location()));
 }
 
@@ -1958 +2001 @@
         m_scaleWasSetByUIProcess = true;
 
+        m_dynamicSizeUpdateHistory.clear();
+
         m_page->setPageScaleFactor(floatBoundedScale, scrollPosition);
-        if (m_drawingArea->layerTreeHost())
-            m_drawingArea->layerTreeHost()->deviceOrPageScaleFactorChanged();
+        if (LayerTreeHost* layerTreeHost = m_drawingArea->layerTreeHost())
+            layerTreeHost->deviceOrPageScaleFactorChanged();
         send(Messages::WebPageProxy::PageScaleFactorDidChange(floatBoundedScale));
     }
 
-    m_page->mainFrame().view()->setScrollOffset(scrollPosition);
-    m_page->mainFrame().view()->setUnobscuredContentRect(roundedUnobscuredRect);
+    FrameView& frameView = *m_page->mainFrame().view();
+    if (scrollPosition != IntPoint(frameView.scrollOffset()))
+        m_dynamicSizeUpdateHistory.clear();
+
+    frameView.setScrollOffset(scrollPosition);
+    frameView.setUnobscuredContentRect(roundedUnobscuredRect);
 
     double horizontalVelocity = visibleContentRectUpdateInfo.horizontalVelocity();
@@ -1972 +2021 @@
     adjustVelocityDataForBoundedScale(horizontalVelocity, verticalVelocity, scaleChangeRate, visibleContentRectUpdateInfo.scale(), boundedScale);
 
-    m_page->mainFrame().view()->setScrollVelocity(horizontalVelocity, verticalVelocity, scaleChangeRate, visibleContentRectUpdateInfo.timestamp());
+    frameView.setScrollVelocity(horizontalVelocity, verticalVelocity, scaleChangeRate, visibleContentRectUpdateInfo.timestamp());
 
     if (visibleContentRectUpdateInfo.inStableState())