Changeset 100196 in webkit

Timestamp:

Nov 14, 2011, 2:47:05 PM (15 years ago)

Author:

fsamuel@chromium.org

Message:

[Chromium] setPageScaleFactor and associated methods should take scaling limits into account
​https://bugs.webkit.org/show_bug.cgi?id=72176

Source/WebKit/chromium:

Reviewed by Darin Fisher.

A couple of changes:

1. setPageScaleFactorLimits now affects the behavior of other scaling methods including setPageScaleFactor.
2. setPageScaleFactorPreservingScrollOffset introduced that scales the scroll offset along with the page, preserving the scroll position within the page bounds.

• public/WebView.h:
• src/WebViewImpl.cpp:

(WebKit::WebViewImpl::WebViewImpl):
(WebKit::WebViewImpl::computePageScaleFactorWithinLimits):
(WebKit::WebViewImpl::clampOffsetAtScale):
(WebKit::WebViewImpl::setPageScaleFactorPreservingScrollOffset):
(WebKit::WebViewImpl::setPageScaleFactor):
(WebKit::WebViewImpl::setPageScaleFactorLimits):
(WebKit::WebViewImpl::applyScrollAndScale):

• src/WebViewImpl.h:

LayoutTests:

Reviewed by Darin Fisher.

Rebaselined some tests that broke because we now clamp pageScaleFactor to 0.25 (these test at 0.2).

Since this is a Chromium only change, the new baselines are only for Chromium.

• platform/chromium-linux/fast/repaint/scale-page-shrink-expected.png:
• platform/chromium-linux/fast/repaint/scale-page-shrink-expected.txt: Added.
• platform/chromium/fast/repaint/background-scaling-expected.png: Copied from LayoutTests/platform/chromium-linux/fast/repaint/scale-page-shrink-expected.png.
• platform/chromium/fast/repaint/background-scaling-expected.txt: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/platform/chromium-linux/fast/repaint/scale-page-shrink-expected.png (modified) ( previous)
• LayoutTests/platform/chromium-linux/fast/repaint/scale-page-shrink-expected.txt (added)
• LayoutTests/platform/chromium/fast/repaint/background-scaling-expected.png (copied) (copied from trunk/LayoutTests/platform/chromium-linux/fast/repaint/scale-page-shrink-expected.png )
• LayoutTests/platform/chromium/fast/repaint/background-scaling-expected.txt (added)
• Source/WebKit/chromium/ChangeLog (modified) (1 diff)
• Source/WebKit/chromium/public/WebView.h (modified) (2 diffs)
• Source/WebKit/chromium/src/WebViewImpl.cpp (modified) (6 diffs)
• Source/WebKit/chromium/src/WebViewImpl.h (modified) (3 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2011-11-14  Fady Samuel  <fsamuel@chromium.org>
+
+        [Chromium] setPageScaleFactor and associated methods should take scaling limits into account
+        https://bugs.webkit.org/show_bug.cgi?id=72176
+
+        Reviewed by Darin Fisher.
+
+        Rebaselined some tests that broke because we now clamp pageScaleFactor to 0.25 (these test at 0.2).
+
+        Since this is a Chromium only change, the new baselines are only for Chromium.
+
+        * platform/chromium-linux/fast/repaint/scale-page-shrink-expected.png:
+        * platform/chromium-linux/fast/repaint/scale-page-shrink-expected.txt: Added.
+        * platform/chromium/fast/repaint/background-scaling-expected.png: Copied from LayoutTests/platform/chromium-linux/fast/repaint/scale-page-shrink-expected.png.
+        * platform/chromium/fast/repaint/background-scaling-expected.txt: Added.
+
 2011-11-14  Robert Hogan  <robert@webkit.org>
 

trunk/Source/WebKit/chromium/ChangeLog

@@ +1 @@
+2011-11-14  Fady Samuel  <fsamuel@chromium.org>
+
+        [Chromium] setPageScaleFactor and associated methods should take scaling limits into account
+        https://bugs.webkit.org/show_bug.cgi?id=72176
+
+        Reviewed by Darin Fisher.
+ 
+        A couple of changes:
+ 
+        1. setPageScaleFactorLimits now affects the behavior of other scaling methods
+           including setPageScaleFactor.
+        2. setPageScaleFactorPreservingScrollOffset introduced that scales the scroll offset 
+           along with the page, preserving the scroll position within the page bounds.
+ 
+
+        * public/WebView.h:
+        * src/WebViewImpl.cpp:
+        (WebKit::WebViewImpl::WebViewImpl):
+        (WebKit::WebViewImpl::computePageScaleFactorWithinLimits):
+        (WebKit::WebViewImpl::clampOffsetAtScale):
+        (WebKit::WebViewImpl::setPageScaleFactorPreservingScrollOffset):
+        (WebKit::WebViewImpl::setPageScaleFactor):
+        (WebKit::WebViewImpl::setPageScaleFactorLimits):
+        (WebKit::WebViewImpl::applyScrollAndScale):
+        * src/WebViewImpl.h:
+
 2011-11-14  Vincent Scheib  <scheib@chromium.org>
 

trunk/Source/WebKit/chromium/public/WebView.h

@@ -62 +62 @@
     WEBKIT_EXPORT static const double minTextSizeMultiplier;
     WEBKIT_EXPORT static const double maxTextSizeMultiplier;
+    WEBKIT_EXPORT static const float minPageScaleFactor;
+    WEBKIT_EXPORT static const float maxPageScaleFactor;
 
     // Controls the time that user scripts injected into the document run.
@@ -208 +210 @@
     WEBKIT_EXPORT static double zoomFactorToZoomLevel(double factor);
 
+    // Gets the scale factor of the page, where 1.0 is the normal size, > 1.0
+    // is scaled up, < 1.0 is scaled down.
+    virtual float pageScaleFactor() const = 0;
+
+    // Scales the page and the scroll offset by a given factor, while ensuring
+    // that the new scroll position does not go beyond the edge of the page.
+    virtual void setPageScaleFactorPreservingScrollOffset(float) = 0;
+
+    // Scales a page by a factor of scaleFactor and then sets a scroll position to (x, y).
+    // setPageScaleFactor() magnifies and shrinks a page without affecting layout.
+    // On the other hand, zooming affects layout of the page.
+    virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin) = 0;
+
     // PageScaleFactor will be force-clamped between minPageScale and maxPageScale
     // (and these values will persist until setPageScaleFactorLimits is called
     // again).
     virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale) = 0;
-
-    // Gets the scale factor of the page, where 1.0 is the normal size, > 1.0
-    // is scaled up, < 1.0 is scaled down.
-    virtual float pageScaleFactor() const = 0;
-
-    // Scales a page by a factor of scaleFactor and then sets a scroll position to (x, y).
-    // setPageScaleFactor() magnifies and shrinks a page without affecting layout.
-    // On the other hand, zooming affects layout of the page.
-    virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin) = 0;
 
     // The ratio of the current device's screen DPI to the target device's screen DPI.

trunk/Source/WebKit/chromium/src/WebViewImpl.cpp

@@ -200 +200 @@
 const double WebView::minTextSizeMultiplier = 0.5;
 const double WebView::maxTextSizeMultiplier = 3.0;
+const float WebView::minPageScaleFactor = 0.25;
+const float WebView::maxPageScaleFactor = 4.0;
 
 
@@ -339 +341 @@
     , m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier))
     , m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier))
+    , m_minimumPageScaleFactor(minPageScaleFactor)
+    , m_maximumPageScaleFactor(maxPageScaleFactor)
     , m_contextMenuAllowed(false)
     , m_doingDragAndDrop(false)
@@ -1853 +1857 @@
 }
 
+float WebViewImpl::computePageScaleFactorWithinLimits(float scaleFactor)
+{
+    return min(max(scaleFactor, m_minimumPageScaleFactor), m_maximumPageScaleFactor);
+}
+
+WebPoint WebViewImpl::clampOffsetAtScale(const WebPoint& offset, float scale)
+{
+    // This is the scaled content size. We need to convert it to the new scale factor.
+    WebSize contentSize = mainFrame()->contentsSize();
+    float deltaScale = scale / pageScaleFactor();
+    int docWidthAtNewScale = contentSize.width * deltaScale;
+    int docHeightAtNewScale = contentSize.height * deltaScale;
+    int viewWidth = m_size.width;
+    int viewHeight = m_size.height;
+
+    // Enforce the maximum and minimum scroll positions at the new scale.
+    IntPoint clampedOffset = offset;
+    clampedOffset.clampNegativeToZero();
+    clampedOffset = clampedOffset.shrunkTo(IntPoint(docWidthAtNewScale - viewWidth, docHeightAtNewScale - viewHeight));
+    return clampedOffset;
+}
+
+void WebViewImpl::setPageScaleFactorPreservingScrollOffset(float scaleFactor)
+{
+    // Pick a scale factor that is within the expected limits
+    scaleFactor = computePageScaleFactorWithinLimits(scaleFactor);
+    if (scaleFactor == pageScaleFactor())
+        return;
+
+    IntPoint scrollOffsetAtNewScale(mainFrame()->scrollOffset().width, mainFrame()->scrollOffset().height);
+    float deltaScale = scaleFactor / pageScaleFactor();
+    scrollOffsetAtNewScale.scale(deltaScale, deltaScale);
+
+    WebPoint clampedOffsetAtNewScale = clampOffsetAtScale(scrollOffsetAtNewScale, scaleFactor);
+    setPageScaleFactor(scaleFactor, clampedOffsetAtNewScale);
+}
+
 void WebViewImpl::setPageScaleFactor(float scaleFactor, const WebPoint& origin)
 {
@@ -1858 +1899 @@
         return;
 
+    if (!scaleFactor)
+        scaleFactor = 1;
+
+    scaleFactor = computePageScaleFactorWithinLimits(scaleFactor);
     page()->setPageScaleFactor(scaleFactor, origin);
 }
@@ -1911 +1956 @@
 void WebViewImpl::setPageScaleFactorLimits(float minPageScale, float maxPageScale)
 {
+    m_minimumPageScaleFactor = min(max(minPageScale, minPageScaleFactor), maxPageScaleFactor) * deviceScaleFactor();
+    m_maximumPageScaleFactor = max(min(maxPageScale, maxPageScaleFactor), minPageScaleFactor) * deviceScaleFactor();
+
+    // Limit page scaling down to the document width.
+    int viewWidth = m_size.width;
+    int unscaledContentWidth = mainFrame()->contentsSize().width / pageScaleFactor();
+    m_minimumPageScaleFactor = max(m_minimumPageScaleFactor,  static_cast<float>(viewWidth) / unscaledContentWidth);
+    ASSERT(minPageScale <= maxPageScale);
 #if USE(ACCELERATED_COMPOSITING)
-    m_layerTreeHost->setPageScaleFactorLimits(minPageScale, maxPageScale);
+    if (m_layerTreeHost)
+        m_layerTreeHost->setPageScaleFactorLimits(m_minimumPageScaleFactor, m_maximumPageScaleFactor);
 #endif
 }
@@ -2731 +2785 @@
     float oldScale = pageScaleFactor();
     if (!oldScale)
-        oldScale = 1.0f;
+        oldScale = 1;
 
     if (!scaleFactor || oldScale == scaleFactor)

trunk/Source/WebKit/chromium/src/WebViewImpl.h

@@ -159 +159 @@
                                    double maximumZoomLevel);
     virtual float pageScaleFactor() const;
+    virtual void setPageScaleFactorPreservingScrollOffset(float);
     virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin);
     virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale);
@@ -418 +419 @@
 
 private:
+    float computePageScaleFactorWithinLimits(float scale);
+    WebPoint clampOffsetAtScale(const WebPoint& offset, float scale);
+
     friend class WebView;  // So WebView::Create can call our constructor
     friend class WTF::RefCounted<WebViewImpl>;
@@ -513 +517 @@
 
     double m_maximumZoomLevel;
+
+    float m_minimumPageScaleFactor;
+
+    float m_maximumPageScaleFactor;
 
     bool m_contextMenuAllowed;