Changeset 167060 in webkit

Timestamp:

Apr 9, 2014 8:39:33 PM (10 years ago)

Author:

benjamin@webkit.org

Message:

[iOS][WK2] Add the initial WebProcess handling of animated resize for rotation
​https://bugs.webkit.org/show_bug.cgi?id=131469

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

Add the basic handling of dynamic resize from the WebProcess.

On animated resize, the UIProcess decides new target rects and scale. The information
is then passed to the WebProcess to update the content.

For various reason, the target rects and scale computed by the UIProcess can be incorrect
(for example, if viewport constraints limit the scale).

In those cases, the WebProcess has all the information to compute a better target. This patch
adds such a basic update mechanism.

Once the new values are computed, they are sent back to the UIProcess. If the rotation animation
is still ongoing, we do not want mess with it. What we do is set a temporary transform on the subviews
and restore the real value after the animation. The key is to have the two matrix multiplying to the end
value so that there is no visual difference.

• UIProcess/API/Cocoa/WKWebView.mm:

(-[WKWebView _didCommitLayerTree:WebKit::]):
(-[WKWebView _dynamicViewportUpdateChangedTargetToScale:position:]):
(setViewportConfigurationMinimumLayoutSize):
(-[WKWebView _frameOrBoundsChanged]):
(-[WKWebView _setMinimumLayoutSizeOverride:]):
(-[WKWebView _beginAnimatedResizeToSize:obscuredInsets:minimumLayoutSizeOverride:]):
(-[WKWebView _endAnimatedResize]):

• UIProcess/API/Cocoa/WKWebViewInternal.h:
• UIProcess/API/ios/WKViewIOS.mm:

(-[WKView _frameOrBoundsChanged]):
(-[WKView setMinimumLayoutSizeOverride:]):

• UIProcess/PageClient.h:
• UIProcess/WebPageProxy.h:
• UIProcess/WebPageProxy.messages.in:
• UIProcess/ios/PageClientImplIOS.h:
• UIProcess/ios/PageClientImplIOS.mm:

(WebKit::PageClientImpl::dynamicViewportUpdateChangedTarget):

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

(-[WKContentView setMinimumLayoutSize:]): Deleted.

• UIProcess/ios/WebPageProxyIOS.mm:

(WebKit::WebPageProxy::dynamicViewportSizeUpdate):
(WebKit::WebPageProxy::dynamicViewportUpdateChangedTarget):

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

(WebKit::WebPage::dynamicViewportSizeUpdate):

Location:

trunk/Source/WebKit2

Files:

• ChangeLog (modified) (1 diff)
• UIProcess/API/Cocoa/WKWebView.mm (modified) (8 diffs)
• UIProcess/API/Cocoa/WKWebViewInternal.h (modified) (1 diff)
• UIProcess/API/ios/WKViewIOS.mm (modified) (2 diffs)
• UIProcess/PageClient.h (modified) (1 diff)
• UIProcess/WebPageProxy.h (modified) (2 diffs)
• UIProcess/WebPageProxy.messages.in (modified) (1 diff)
• UIProcess/ios/PageClientImplIOS.h (modified) (1 diff)
• UIProcess/ios/PageClientImplIOS.mm (modified) (1 diff)
• UIProcess/ios/WKContentView.h (modified) (1 diff)
• UIProcess/ios/WKContentView.mm (modified) (1 diff)
• UIProcess/ios/WebPageProxyIOS.mm (modified) (2 diffs)
• WebProcess/WebPage/WebPage.h (modified) (1 diff)
• WebProcess/WebPage/WebPage.messages.in (modified) (1 diff)
• WebProcess/WebPage/ios/WebPageIOS.mm (modified) (1 diff)

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2014-04-09  Benjamin Poulain  <bpoulain@apple.com>
+
+        [iOS][WK2] Add the initial WebProcess handling of animated resize for rotation
+        https://bugs.webkit.org/show_bug.cgi?id=131469
+
+        Reviewed by Tim Horton.
+
+        Add the basic handling of dynamic resize from the WebProcess.
+
+        On animated resize, the UIProcess decides new target rects and scale. The information
+        is then passed to the WebProcess to update the content.
+
+        For various reason, the target rects and scale computed by the UIProcess can be incorrect
+        (for example, if viewport constraints limit the scale).
+
+        In those cases, the WebProcess has all the information to compute a better target. This patch
+        adds such a basic update mechanism.
+
+        Once the new values are computed, they are sent back to the UIProcess. If the rotation animation
+        is still ongoing, we do not want mess with it. What we do is set a temporary transform on the subviews
+        and restore the real value after the animation. The key is to have the two matrix multiplying to the end
+        value so that there is no visual difference.
+
+        * UIProcess/API/Cocoa/WKWebView.mm:
+        (-[WKWebView _didCommitLayerTree:WebKit::]):
+        (-[WKWebView _dynamicViewportUpdateChangedTargetToScale:position:]):
+        (setViewportConfigurationMinimumLayoutSize):
+        (-[WKWebView _frameOrBoundsChanged]):
+        (-[WKWebView _setMinimumLayoutSizeOverride:]):
+        (-[WKWebView _beginAnimatedResizeToSize:obscuredInsets:minimumLayoutSizeOverride:]):
+        (-[WKWebView _endAnimatedResize]):
+        * UIProcess/API/Cocoa/WKWebViewInternal.h:
+        * UIProcess/API/ios/WKViewIOS.mm:
+        (-[WKView _frameOrBoundsChanged]):
+        (-[WKView setMinimumLayoutSizeOverride:]):
+        * UIProcess/PageClient.h:
+        * UIProcess/WebPageProxy.h:
+        * UIProcess/WebPageProxy.messages.in:
+        * UIProcess/ios/PageClientImplIOS.h:
+        * UIProcess/ios/PageClientImplIOS.mm:
+        (WebKit::PageClientImpl::dynamicViewportUpdateChangedTarget):
+        * UIProcess/ios/WKContentView.h:
+        * UIProcess/ios/WKContentView.mm:
+        (-[WKContentView setMinimumLayoutSize:]): Deleted.
+        * UIProcess/ios/WebPageProxyIOS.mm:
+        (WebKit::WebPageProxy::dynamicViewportSizeUpdate):
+        (WebKit::WebPageProxy::dynamicViewportUpdateChangedTarget):
+        * WebProcess/WebPage/WebPage.h:
+        * WebProcess/WebPage/WebPage.messages.in:
+        * WebProcess/WebPage/ios/WebPageIOS.mm:
+        (WebKit::WebPage::dynamicViewportSizeUpdate):
+
 2014-04-09  Martin Robinson  <mrobinson@igalia.com>
 

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

@@ -65 +65 @@
 #import "WKScrollView.h"
 #import "WKWebViewContentProviderRegistry.h"
+#import <CoreGraphics/CGFloat.h>
 #import <UIKit/UIPeripheralHost_Private.h>
 
@@ -101 +102 @@
     bool _isChangingObscuredInsetsInteractively;
     BOOL _isAnimatingResize;
+    CATransform3D _resizeAnimationTransformAdjustments;
     CGFloat _lastAdjustmentForScroller;
     CGFloat _keyboardVerticalOverlap;
@@ -451 +453 @@
     ASSERT(!_customContentView);
 
-    if (_isAnimatingResize)
+    if (_isAnimatingResize) {
+        [_contentView layer].sublayerTransform = _resizeAnimationTransformAdjustments;
         return;
+    }
 
     [_scrollView setContentSize:[_contentView frame].size];
@@ -471 +475 @@
         _isWaitingForNewLayerTreeAfterDidCommitLoad = NO;
     }
-
+}
+
+- (void)_dynamicViewportUpdateChangedTargetToScale:(double)newScale position:(CGPoint)newScrollPosition
+{
+    if (_isAnimatingResize) {
+        double currentTargetScale = [[_contentView layer] affineTransform].a;
+        double scale = newScale / currentTargetScale;
+        _resizeAnimationTransformAdjustments = CATransform3DMakeScale(scale, scale, 0);
+
+        CGPoint newContentOffset = CGPointMake(newScrollPosition.x * newScale, newScrollPosition.y * newScale);
+        newContentOffset.x -= _obscuredInsets.left;
+        newContentOffset.y -= _obscuredInsets.top;
+        CGPoint currentContentOffset = [_scrollView contentOffset];
+
+        _resizeAnimationTransformAdjustments.m41 = (currentContentOffset.x - newContentOffset.x) / currentTargetScale;
+        _resizeAnimationTransformAdjustments.m42 = (currentContentOffset.y - newContentOffset.y) / currentTargetScale;
+    }
 }
 
@@ -677 +697 @@
 }
 
+static inline void setViewportConfigurationMinimumLayoutSize(WebKit::WebPageProxy& page, const CGSize& size)
+{
+    page.setViewportConfigurationMinimumLayoutSize(WebCore::IntSize(CGCeiling(size.width), CGCeiling(size.height)));
+}
+
 - (void)_frameOrBoundsChanged
 {
     CGRect bounds = self.bounds;
     if (!_hasStaticMinimumLayoutSize && !_isAnimatingResize)
-        [_contentView setMinimumLayoutSize:bounds.size];
+        setViewportConfigurationMinimumLayoutSize(*_page, bounds.size);
     [_scrollView setFrame:bounds];
     [_contentView setMinimumSize:bounds.size];
@@ -1165 +1190 @@
     _hasStaticMinimumLayoutSize = YES;
     _minimumLayoutSizeOverride = minimumLayoutSizeOverride;
-    [_contentView setMinimumLayoutSize:minimumLayoutSizeOverride];
+    setViewportConfigurationMinimumLayoutSize(*_page, minimumLayoutSizeOverride);
 }
 
@@ -1209 +1234 @@
 {
     _isAnimatingResize = YES;
+    _resizeAnimationTransformAdjustments = CATransform3DIdentity;
 
     if (_customContentView)
@@ -1263 +1289 @@
     [_scrollView setContentOffset:contentOffset];
 
-    // FIXME: Send a single message to the WebProcess to layout and repaint instead.
-    // FIXME: Send resize event.
-    [_contentView setMinimumLayoutSize:futureMinimumLayoutSize];
+    CGRect visibleRectInContentCoordinates = [self convertRect:futureBounds toView:_contentView.get()];
+
+    CGRect unobscuredRect = UIEdgeInsetsInsetRect(futureBounds, _obscuredInsets);
+    CGRect unobscuredRectInContentCoordinates = [self convertRect:unobscuredRect toView:_contentView.get()];
+
+    _page->dynamicViewportSizeUpdate(WebCore::IntSize(CGCeiling(futureMinimumLayoutSize.width), CGCeiling(futureMinimumLayoutSize.height)), visibleRectInContentCoordinates, unobscuredRectInContentCoordinates, targetScale);
 }
 
 - (void)_endAnimatedResize
 {
+    if (!_customContentView) {
+        CALayer *contentViewLayer = [_contentView layer];
+        CATransform3D resizeAnimationTransformAdjustements = _resizeAnimationTransformAdjustments;
+        CGFloat adjustmentScale = resizeAnimationTransformAdjustements.m11;
+        contentViewLayer.sublayerTransform = CATransform3DIdentity;
+
+        CGFloat currentScale = contentZoomScale(self);
+        CGPoint currentScrollOffset = [_scrollView contentOffset];
+        [_scrollView setZoomScale:adjustmentScale * currentScale];
+
+        double horizontalScrollAdjustement = _resizeAnimationTransformAdjustments.m41 * currentScale;
+        double verticalScrollAdjustment = _resizeAnimationTransformAdjustments.m42 * currentScale;
+
+        [_scrollView setContentOffset:CGPointMake(currentScrollOffset.x - horizontalScrollAdjustement, currentScrollOffset.y - verticalScrollAdjustment)];
+    }
+
+    _resizeAnimationTransformAdjustments = CATransform3DIdentity;
     _isAnimatingResize = NO;
     [self _updateVisibleContentRects];

trunk/Source/WebKit2/UIProcess/API/Cocoa/WKWebViewInternal.h

@@ -61 +61 @@
 - (void)_didCommitLayerTree:(const WebKit::RemoteLayerTreeTransaction&)layerTreeTransaction;
 
+- (void)_dynamicViewportUpdateChangedTargetToScale:(double)newScale position:(CGPoint)newScrollPosition;
+
 - (RetainPtr<CGImageRef>)_takeViewSnapshot;
 

trunk/Source/WebKit2/UIProcess/API/ios/WKViewIOS.mm

@@ -249 +249 @@
 {
     CGRect bounds = [self bounds];
-    if (!_hasStaticMinimumLayoutSize)
-        [_contentView setMinimumLayoutSize:bounds.size];
     [_scrollView setFrame:bounds];
     [_contentView setMinimumSize:bounds.size];
@@ -337 +335 @@
     _hasStaticMinimumLayoutSize = YES;
     _minimumLayoutSizeOverride = minimumLayoutSizeOverride;
-    [_contentView setMinimumLayoutSize:minimumLayoutSizeOverride];
 }
 

trunk/Source/WebKit2/UIProcess/PageClient.h

@@ -240 +240 @@
 
     virtual void didCommitLayerTree(const RemoteLayerTreeTransaction&) = 0;
+    virtual void dynamicViewportUpdateChangedTarget(double newScale, const WebCore::FloatPoint& newScrollPosition) = 0;
 
     virtual void startAssistingNode(const AssistedNodeInformation&, API::Object* userData) = 0;

trunk/Source/WebKit2/UIProcess/WebPageProxy.h

@@ -577 +577 @@
     uint64_t nextVisibleContentRectUpdateID() const { return m_lastVisibleContentRectUpdate.updateID() + 1; }
     uint64_t lastVisibleContentRectUpdateID() const { return m_lastVisibleContentRectUpdate.updateID(); }
+
+    void dynamicViewportSizeUpdate(const WebCore::IntSize& minimumLayoutSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, double targetScale);
     
     void setViewportConfigurationMinimumLayoutSize(const WebCore::IntSize&);
@@ -1334 +1336 @@
     WebCore::FloatSize viewportScreenSize();
 
+    void dynamicViewportUpdateChangedTarget(double newTargetScale, const WebCore::FloatPoint& newScrollPosition);
     void didGetTapHighlightGeometries(uint64_t requestID, const WebCore::Color& color, const Vector<WebCore::FloatQuad>& geometries, const WebCore::IntSize& topLeftRadius, const WebCore::IntSize& topRightRadius, const WebCore::IntSize& bottomLeftRadius, const WebCore::IntSize& bottomRightRadius);
 

trunk/Source/WebKit2/UIProcess/WebPageProxy.messages.in

@@ -317 +317 @@
 
 #if PLATFORM(IOS)
+    DynamicViewportUpdateChangedTarget(double newTargetScale, WebCore::FloatPoint newScrollPosition)
     DidGetTapHighlightGeometries(uint64_t requestID, WebCore::Color color, Vector<WebCore::FloatQuad> geometries, WebCore::IntSize topLeftRadius, WebCore::IntSize topRightRadius, WebCore::IntSize bottomLeftRadius, WebCore::IntSize bottomRightRadius)
 

trunk/Source/WebKit2/UIProcess/ios/PageClientImplIOS.h

@@ -107 +107 @@
 
     virtual void didCommitLayerTree(const RemoteLayerTreeTransaction&) override;
+    virtual void dynamicViewportUpdateChangedTarget(double newScale, const WebCore::FloatPoint& newScrollPosition) override;
 
     virtual void startAssistingNode(const AssistedNodeInformation&, API::Object* userData) override;

trunk/Source/WebKit2/UIProcess/ios/PageClientImplIOS.mm

@@ -363 +363 @@
 }
 
+void PageClientImpl::dynamicViewportUpdateChangedTarget(double newScale, const WebCore::FloatPoint& newScrollPosition)
+{
+    [m_webView _dynamicViewportUpdateChangedTargetToScale:newScale position:newScrollPosition];
+}
+
 void PageClientImpl::startAssistingNode(const AssistedNodeInformation& nodeInformation, API::Object* userData)
 {

trunk/Source/WebKit2/UIProcess/ios/WKContentView.h

@@ -61 +61 @@
 
 - (void)setMinimumSize:(CGSize)size;
-- (void)setMinimumLayoutSize:(CGSize)size;
 - (void)didUpdateVisibleRect:(CGRect)visibleRect unobscuredRect:(CGRect)unobscuredRect scale:(CGFloat)scale inStableState:(BOOL)isStableState;
 

trunk/Source/WebKit2/UIProcess/ios/WKContentView.mm

@@ -330 +330 @@
 }
 
-- (void)setMinimumLayoutSize:(CGSize)size
-{
-    _page->setViewportConfigurationMinimumLayoutSize(IntSize(CGCeiling(size.width), CGCeiling(size.height)));
-}
-
 - (void)didFinishScrolling
 {

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

@@ -189 +189 @@
 }
 
+void WebPageProxy::dynamicViewportSizeUpdate(const IntSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
+{
+    m_process->send(Messages::WebPage::DynamicViewportSizeUpdate(minimumLayoutSize, targetExposedContentRect, targetUnobscuredRect, targetScale), m_pageID);
+}
+
 void WebPageProxy::setViewportConfigurationMinimumLayoutSize(const WebCore::IntSize& size)
 {
@@ -459 +464 @@
 }
 
+void WebPageProxy::dynamicViewportUpdateChangedTarget(double newScale, const WebCore::FloatPoint& newScrollPosition)
+{
+    m_pageClient.dynamicViewportUpdateChangedTarget(newScale, newScrollPosition);
+}
+
 void WebPageProxy::didGetTapHighlightGeometries(uint64_t requestID, const WebCore::Color& color, const Vector<WebCore::FloatQuad>& highlightedQuads, const WebCore::IntSize& topLeftRadius, const WebCore::IntSize& topRightRadius, const WebCore::IntSize& bottomLeftRadius, const WebCore::IntSize& bottomRightRadius)
 {

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

@@ -693 +693 @@
 #if PLATFORM(IOS)
     void setViewportConfigurationMinimumLayoutSize(const WebCore::IntSize&);
+    void dynamicViewportSizeUpdate(const WebCore::IntSize& minimumLayoutSize, const WebCore::FloatRect& targetExposedContentRect, const WebCore::FloatRect& targetUnobscuredRect, double scale);
     void viewportConfigurationChanged();
     void updateVisibleContentRects(const VisibleContentRectUpdateInfo&);

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

@@ -45 +45 @@
 #if PLATFORM(IOS)
     SetViewportConfigurationMinimumLayoutSize(WebCore::IntSize size)
+    DynamicViewportSizeUpdate(WebCore::IntSize minimumLayoutSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, double scale)
 
     HandleTap(WebCore::IntPoint point)

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

@@ -1710 +1710 @@
 }
 
+void WebPage::dynamicViewportSizeUpdate(const IntSize& minimumLayoutSize, const FloatRect& targetExposedContentRect, const FloatRect& targetUnobscuredRect, double targetScale)
+{
+    // 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.
+
+    FrameView& frameView = *m_page->mainFrame().view();
+    IntSize oldContentSize = frameView.contentsSize();
+
+    m_viewportConfiguration.setMinimumLayoutSize(minimumLayoutSize);
+    IntSize newLayoutSize = m_viewportConfiguration.layoutSize();
+    setFixedLayoutSize(newLayoutSize);
+    frameView.updateLayoutAndStyleIfNeededRecursive();
+
+    IntSize newContentSize = frameView.contentsSize();
+
+    double scale;
+    if (!m_userHasChangedPageScaleFactor)
+        scale = m_viewportConfiguration.initialScale();
+    else
+        scale = std::max(std::min(targetScale, m_viewportConfiguration.maximumScale()), m_viewportConfiguration.minimumScale());
+
+    FloatRect newUnobscuredContentRect = targetUnobscuredRect;
+    FloatRect newExposedContentRect = targetExposedContentRect;
+
+    if (scale != targetScale) {
+        // The target scale the UI is using cannot be reached by the content. We need to compute new targets based
+        // on the viewport constraint and report everything back to the UIProcess.
+
+        // 1) Compute a new unobscured rect centered around the original one.
+        double scaleDifference = targetScale / scale;
+        double newUnobscuredRectWidth = targetUnobscuredRect.width() * scaleDifference;
+        double newUnobscuredRectHeight = targetUnobscuredRect.height() * scaleDifference;
+        double newUnobscuredRectX = targetUnobscuredRect.x() - (newUnobscuredRectWidth - targetUnobscuredRect.width()) / 2;
+        double newUnobscuredRectY = targetUnobscuredRect.y() - (newUnobscuredRectHeight - targetUnobscuredRect.height()) / 2;
+        newUnobscuredContentRect = FloatRect(newUnobscuredRectX, newUnobscuredRectY, newUnobscuredRectWidth, newUnobscuredRectHeight);
+
+        // 2) Extend our new unobscuredRect by the obscured margins to get a new exposed rect.
+        double obscuredTopMargin = (targetUnobscuredRect.y() - targetExposedContentRect.y()) * scaleDifference;
+        double obscuredLeftMargin = (targetUnobscuredRect.x() - targetExposedContentRect.x()) * scaleDifference;
+        double obscuredBottomMargin = (targetExposedContentRect.maxY() - targetUnobscuredRect.maxY()) * scaleDifference;
+        double obscuredRightMargin = (targetExposedContentRect.maxX() - targetUnobscuredRect.maxX()) * scaleDifference;
+        newExposedContentRect = FloatRect(newUnobscuredRectX - obscuredLeftMargin,
+                                          newUnobscuredRectY - obscuredTopMargin,
+                                          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()));
+
+        double horizontalAdjustment = 0;
+        if (newExposedContentRect.maxX() > newContentSize.width())
+            horizontalAdjustment -= newExposedContentRect.maxX() - newContentSize.width();
+        double verticalAdjustment = 0;
+        if (newExposedContentRect.maxY() > newContentSize.height())
+            verticalAdjustment -= newExposedContentRect.maxY() - newContentSize.height();
+        if (newExposedContentRect.x() < 0)
+            horizontalAdjustment += - newExposedContentRect.x();
+        if (newExposedContentRect.y() < 0)
+            verticalAdjustment += - newExposedContentRect.y();
+
+        newUnobscuredContentRect.move(horizontalAdjustment, verticalAdjustment);
+        newExposedContentRect.move(horizontalAdjustment, verticalAdjustment);
+    }
+
+    frameView.setScrollVelocity(0, 0, 0, monotonicallyIncreasingTime());
+
+    IntRect roundedUnobscuredContentRect = roundedIntRect(newUnobscuredContentRect);
+    frameView.setScrollOffset(roundedUnobscuredContentRect.location());
+    frameView.setUnobscuredContentRect(roundedUnobscuredContentRect);
+    m_drawingArea->setExposedContentRect(newExposedContentRect);
+
+    if (scale == targetScale)
+        scalePage(scale, frameView.scrollPosition());
+
+    if (scale != targetScale || roundedIntPoint(targetUnobscuredRect.location()) != roundedUnobscuredContentRect.location())
+        send(Messages::WebPageProxy::DynamicViewportUpdateChangedTarget(scale, frameView.scrollPosition()));
+}
+
 void WebPage::viewportConfigurationChanged()
 {