Imported WebKit commit c596dd7f03007fa7ed896b928106497e8784b3b5 (http://svn.webkit.org/repository/webkit/trunk@129610)

New snapshot that removes QtQuick1 support (to be moved into QtQuick1 module)

1 files changed, 43 insertions, 63 deletions

diff --git a/Source/WebKit2/UIProcess/PageViewportController.cpp b/Source/WebKit2/UIProcess/PageViewportController.cpp
index e9a513af1..e42006a14 100644
--- a/Source/WebKit2/UIProcess/PageViewportController.cpp
+++ b/Source/WebKit2/UIProcess/PageViewportController.cpp
@@ -32,21 +32,11 @@ using namespace WebCore;
 
 namespace WebKit {
 
-static inline float bound(float min, float value, float max)
-{
-    return clampTo<float>(value, min, max);
-}
-
 bool fuzzyCompare(float a, float b, float epsilon)
 {
     return std::abs(a - b) < epsilon;
 }
 
-FloatPoint boundPosition(const FloatPoint minPosition, const FloatPoint& position, const FloatPoint& maxPosition)
-{
-    return FloatPoint(bound(minPosition.x(), position.x(), maxPosition.x()), bound(minPosition.y(), position.y(), maxPosition.y()));
-}
-
 ViewportUpdateDeferrer::ViewportUpdateDeferrer(PageViewportController* PageViewportController, SuspendContentFlag suspendContentFlag)
     : m_controller(PageViewportController)
 {
@@ -73,9 +63,7 @@ PageViewportController::PageViewportController(WebKit::WebPageProxy* proxy, Page
     : m_webPageProxy(proxy)
     , m_client(client)
     , m_allowsUserScaling(false)
-    , m_minimumScale(1)
-    , m_maximumScale(1)
-    , m_devicePixelRatio(1)
+    , m_minimumScaleToFit(1)
     , m_activeDeferrerCount(0)
     , m_hasSuspendedContent(false)
     , m_hadUserInteraction(false)
@@ -84,38 +72,41 @@ PageViewportController::PageViewportController(WebKit::WebPageProxy* proxy, Page
     // Initializing Viewport Raw Attributes to avoid random negative scale factors
     // if there is a race condition between the first layout and setting the viewport attributes for the first time.
     m_rawAttributes.initialScale = 1;
-    m_rawAttributes.minimumScale = m_minimumScale;
-    m_rawAttributes.maximumScale = m_maximumScale;
+    m_rawAttributes.minimumScale = 1;
+    m_rawAttributes.maximumScale = 1;
     m_rawAttributes.userScalable = m_allowsUserScaling;
 
     ASSERT(m_client);
     m_client->setController(this);
 }
 
-FloatRect PageViewportController::convertToViewport(const FloatRect& cssRect) const
-{
-    return FloatRect(
-        convertToViewport(cssRect.x()),
-        convertToViewport(cssRect.y()),
-        convertToViewport(cssRect.width()),
-        convertToViewport(cssRect.height())
-    );
-}
-
-float PageViewportController::innerBoundedContentsScale(float cssScale) const
+float PageViewportController::innerBoundedViewportScale(float viewportScale) const
 {
-    return bound(m_minimumScale, cssScale, m_maximumScale);
+    return clampTo(viewportScale, toViewportScale(m_minimumScaleToFit), toViewportScale(m_rawAttributes.maximumScale));
 }
 
-float PageViewportController::outerBoundedContentsScale(float cssScale) const
+float PageViewportController::outerBoundedViewportScale(float viewportScale) const
 {
     if (m_allowsUserScaling) {
         // Bounded by [0.1, 10.0] like the viewport meta code in WebCore.
-        float hardMin = std::max<float>(0.1, 0.5 * m_minimumScale);
-        float hardMax = std::min<float>(10, 2 * m_maximumScale);
-        return bound(hardMin, cssScale, hardMax);
+        float hardMin = toViewportScale(std::max<float>(0.1, 0.5 * m_minimumScaleToFit));
+        float hardMax = toViewportScale(std::min<float>(10, 2 * m_rawAttributes.maximumScale));
+        return clampTo(viewportScale, hardMin, hardMax);
     }
-    return innerBoundedContentsScale(cssScale);
+    return innerBoundedViewportScale(viewportScale);
+}
+
+float PageViewportController::devicePixelRatio() const
+{
+    return m_webPageProxy->deviceScaleFactor();
+}
+
+FloatPoint PageViewportController::clampViewportToContents(const WebCore::FloatPoint& viewportPos, float viewportScale)
+{
+    const float horizontalRange = std::max(0.f, m_contentsSize.width() - m_viewportSize.width() / viewportScale);
+    const float verticalRange = std::max(0.f, m_contentsSize.height() - m_viewportSize.height() / viewportScale);
+
+    return FloatPoint(clampTo(viewportPos.x(), 0.f, horizontalRange), clampTo(viewportPos.y(), 0.f, verticalRange));
 }
 
 void PageViewportController::didChangeContentsSize(const IntSize& newSize)
@@ -124,17 +115,7 @@ void PageViewportController::didChangeContentsSize(const IntSize& newSize)
         return;
 
     m_contentsSize = newSize;
-
-    float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), newSize);
-
-    if (!fuzzyCompare(minimumScale, m_rawAttributes.minimumScale, 0.001)) {
-        m_minimumScale = minimumScale;
-
-        if (!m_hadUserInteraction && !hasSuspendedContent())
-            m_client->setContentsScale(convertToViewport(minimumScale), true /* isInitialScale */);
-
-        m_client->didChangeViewportAttributes();
-    }
+    updateMinimumScaleToFit();
 
     m_client->didChangeContentsSize();
 }
@@ -145,15 +126,10 @@ void PageViewportController::pageDidRequestScroll(const IntPoint& cssPosition)
     if (m_activeDeferrerCount)
         return;
 
-    FloatRect endPosRange = positionRangeForContentAtScale(m_effectiveScale);
-    FloatPoint endPosition(cssPosition);
-    endPosition.scale(m_effectiveScale, m_effectiveScale);
-    endPosition = boundPosition(endPosRange.minXMinYCorner(), endPosition, endPosRange.maxXMaxYCorner());
-
-    m_client->setContentsPosition(endPosition);
+    m_client->setViewportPosition(clampViewportToContents(cssPosition, m_effectiveScale));
 }
 
-void PageViewportController::setViewportSize(const FloatSize& newSize)
+void PageViewportController::didChangeViewportSize(const FloatSize& newSize)
 {
     if (newSize.isEmpty())
         return;
@@ -167,9 +143,9 @@ void PageViewportController::setViewportSize(const FloatSize& newSize)
     syncVisibleContents();
 }
 
-void PageViewportController::setVisibleContentsRect(const FloatRect& visibleContentsRect, float viewportScale, const FloatPoint& trajectoryVector)
+void PageViewportController::didChangeContentsVisibility(const FloatPoint& viewportPos, float viewportScale, const FloatPoint& trajectoryVector)
 {
-    m_visibleContentsRect = visibleContentsRect;
+    m_viewportPos = viewportPos;
     m_effectiveScale = viewportScale;
     syncVisibleContents(trajectoryVector);
 }
@@ -177,10 +153,12 @@ void PageViewportController::setVisibleContentsRect(const FloatRect& visibleCont
 void PageViewportController::syncVisibleContents(const FloatPoint& trajectoryVector)
 {
     DrawingAreaProxy* const drawingArea = m_webPageProxy->drawingArea();
-    if (!drawingArea || m_viewportSize.isEmpty() || m_contentsSize.isEmpty() || m_visibleContentsRect.isEmpty())
+    if (!drawingArea || m_viewportSize.isEmpty() || m_contentsSize.isEmpty())
         return;
 
-    drawingArea->setVisibleContentsRect(m_visibleContentsRect, m_effectiveScale, trajectoryVector);
+    FloatRect visibleContentsRect(clampViewportToContents(m_viewportPos, m_effectiveScale), m_viewportSize / m_effectiveScale);
+    visibleContentsRect.intersect(FloatRect(FloatPoint::zero(), m_contentsSize));
+    drawingArea->setVisibleContentsRect(visibleContentsRect, m_effectiveScale, trajectoryVector);
 
     m_client->didChangeVisibleContents();
 }
@@ -193,10 +171,8 @@ void PageViewportController::didChangeViewportAttributes(const WebCore::Viewport
     m_rawAttributes = newAttributes;
     WebCore::restrictScaleFactorToInitialScaleIfNotUserScalable(m_rawAttributes);
 
-    m_devicePixelRatio = m_webPageProxy->deviceScaleFactor();
     m_allowsUserScaling = !!m_rawAttributes.userScalable;
-    m_minimumScale = m_rawAttributes.minimumScale;
-    m_maximumScale = m_rawAttributes.maximumScale;
+    updateMinimumScaleToFit();
 
     m_client->didChangeViewportAttributes();
 }
@@ -214,7 +190,7 @@ void PageViewportController::resumeContent()
 {
     if (!m_rawAttributes.layoutSize.isEmpty() && m_rawAttributes.initialScale > 0) {
         m_hadUserInteraction = false;
-        m_client->setContentsScale(convertToViewport(innerBoundedContentsScale(m_rawAttributes.initialScale)), /* isInitialScale */ true);
+        m_client->setContentsScale(innerBoundedViewportScale(toViewportScale(m_rawAttributes.initialScale)), /* isInitialScale */ true);
         m_rawAttributes.initialScale = -1; // Mark used.
     }
 
@@ -227,14 +203,18 @@ void PageViewportController::resumeContent()
     m_webPageProxy->resumeActiveDOMObjectsAndAnimations();
 }
 
-FloatRect PageViewportController::positionRangeForContentAtScale(float viewportScale) const
+void PageViewportController::updateMinimumScaleToFit()
 {
-    const FloatSize contentSize = m_contentsSize * viewportScale;
+    float minimumScale = WebCore::computeMinimumScaleFactorForContentContained(m_rawAttributes, WebCore::roundedIntSize(m_viewportSize), WebCore::roundedIntSize(m_contentsSize));
 
-    const float horizontalRange = contentSize.width() - m_viewportSize.width();
-    const float verticalRange = contentSize.height() - m_viewportSize.height();
+    if (!fuzzyCompare(minimumScale, m_minimumScaleToFit, 0.001)) {
+        m_minimumScaleToFit = minimumScale;
 
-    return FloatRect(0, 0, horizontalRange, verticalRange);
+        if (!m_hadUserInteraction && !hasSuspendedContent())
+            m_client->setContentsScale(toViewportScale(minimumScale), true /* isInitialScale */);
+
+        m_client->didChangeViewportAttributes();
+    }
 }
 
 } // namespace WebKit