Refactor viewport initialization logic out of WebViewImpl.

Source/WebKit/chromium/src/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 195 matching lines @@
 
 namespace WebKit {
 
 // Change the text zoom level by kTextSizeMultiplierRatio each time the user
 // zooms text in or out (ie., change by 20%).  The min and max values limit
 // text zoom to half and 3x the original text size.  These three values match
 // those in Apple's port in WebKit/WebKit/WebView/WebView.mm
 const double WebView::textSizeMultiplierRatio = 1.2;
 const double WebView::minTextSizeMultiplier = 0.5;
 const double WebView::maxTextSizeMultiplier = 3.0;
-const float WebView::minPageScaleFactor = 0.25f;
-const float WebView::maxPageScaleFactor = 4.0f;
 
 // Used to defer all page activity in cases where the embedder wishes to run
 // a nested event loop. Using a stack enables nesting of message loop invocations.
 static Vector<PageGroupLoadDeferrer*>& pageGroupLoadDeferrerStack()
 {
     DEFINE_STATIC_LOCAL(Vector<PageGroupLoadDeferrer*>, deferrerStack, ());
     return deferrerStack;
 }
 
 // Ensure that the WebDragOperation enum values stay in sync with the original
@@ skipping 153 matching lines @@
     , m_inspectorClientImpl(this)
     , m_backForwardClientImpl(this)
     , m_shouldAutoResize(false)
     , m_observedNewNavigation(false)
 #ifndef NDEBUG
     , m_newNavigationLoader(0)
 #endif
     , m_zoomLevel(0)
     , m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier))
     , m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier))
-    , m_pageDefinedMinimumPageScaleFactor(-1)
-    , m_pageDefinedMaximumPageScaleFactor(-1)
-    , m_minimumPageScaleFactor(minPageScaleFactor)
-    , m_maximumPageScaleFactor(maxPageScaleFactor)
-    , m_initialPageScaleFactorOverride(-1)
-    , m_initialPageScaleFactor(-1)
-    , m_ignoreViewportTagMaximumScale(false)
-    , m_pageScaleFactorIsSet(false)
     , m_savedPageScaleFactor(0)
     , m_doubleTapZoomPageScaleFactor(0)
     , m_doubleTapZoomPending(false)
     , m_enableFakeDoubleTapAnimationForTesting(false)
     , m_fakeDoubleTapPageScaleFactor(0)
     , m_fakeDoubleTapUseAnchor(false)
     , m_contextMenuAllowed(false)
     , m_doingDragAndDrop(false)
     , m_ignoreInputEvents(false)
     , m_suppressNextKeypressEvent(false)
@@ skipping 73 matching lines @@
 #if ENABLE(BATTERY_STATUS)
     provideBatteryTo(m_page.get(), m_batteryClient.get());
     m_batteryClient->setController(BatteryController::from(m_page.get()));
 #endif
 
     m_page->setGroupType(Page::SharedPageGroup);
 
     unsigned layoutMilestones = DidFirstLayout | DidFirstVisuallyNonEmptyLayout;
     m_page->addLayoutMilestones(static_cast<LayoutMilestones>(layoutMilestones));
 
-    if (m_client)
+    if (m_client) {
+        setDeviceScaleFactor(m_client->screenInfo().deviceScaleFactor);
         setVisibilityState(m_client->visibilityState(), true);
+    }
 
     m_inspectorSettingsMap = adoptPtr(new SettingsMap);
 }
 
 WebViewImpl::~WebViewImpl()
 {
     ASSERT(!m_page);
 }
 
 RenderTheme* WebViewImpl::theme() const
@@ skipping 287 matching lines @@
         m_contextMenuAllowed = false;
 
         break;
     }
     case WebInputEvent::GestureTapDown: {
         m_client->cancelScheduledContentIntents();
         eventSwallowed = mainFrameImpl()->frame()->eventHandler()->handleGestureEvent(platformEvent);
         break;
     }
     case WebInputEvent::GestureDoubleTap:
-        if (m_webSettings->doubleTapToZoomEnabled() && m_minimumPageScaleFactor != m_maximumPageScaleFactor) {
+        if (m_webSettings->doubleTapToZoomEnabled() && minimumPageScaleFactor() != maximumPageScaleFactor()) {
             m_client->cancelScheduledContentIntents();
             animateZoomAroundPoint(platformEvent.position(), DoubleTap);
         }
         // GestureDoubleTap is currently only used by Android for zooming. For WebCore,
         // GestureTap with tap count = 2 is used instead. So we drop GestureDoubleTap here.
         eventSwallowed = true;
         break;
     case WebInputEvent::GestureScrollBegin:
     case WebInputEvent::GesturePinchBegin:
         m_client->cancelScheduledContentIntents();
@@ skipping 348 matching lines @@
         // be visible). FIXME: Revisit this if it isn't always true.
         return;
     }
 
     bool scaleUnchanged = true;
     if (!rect.isEmpty()) {
         // Pages should be as legible as on desktop when at dpi scale, so no
         // need to zoom in further when automatically determining zoom level
         // (after double tap, find in page, etc), though the user should still
         // be allowed to manually pinch zoom in further if they desire.
-        const float defaultScaleWhenAlreadyLegible = m_minimumPageScaleFactor * doubleTapZoomAlreadyLegibleRatio;
+        const float defaultScaleWhenAlreadyLegible = minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
         float legibleScale = 1;
         if (page() && page()->settings())
             legibleScale *= page()->settings()->textAutosizingFontScaleFactor();
         if (legibleScale < defaultScaleWhenAlreadyLegible)
-            legibleScale = (scale == m_minimumPageScaleFactor) ? defaultScaleWhenAlreadyLegible : m_minimumPageScaleFactor;
+            legibleScale = (scale == minimumPageScaleFactor()) ? defaultScaleWhenAlreadyLegible : minimumPageScaleFactor();
 
         float defaultMargin = doubleTapZoomContentDefaultMargin;
         float minimumMargin = doubleTapZoomContentMinimumMargin;
         // We want the margins to have the same physical size, which means we
         // need to express them in post-scale size. To do that we'd need to know
         // the scale we're scaling to, but that depends on the margins. Instead
         // we express them as a fraction of the target rectangle: this will be
         // correct if we end up fully zooming to it, and won't matter if we
         // don't.
         rect = widenRectWithinPageBounds(rect,
                 static_cast<int>(defaultMargin * rect.width / m_size.width),
                 static_cast<int>(minimumMargin * rect.width / m_size.width));
         // Fit block to screen, respecting limits.
         scale = static_cast<float>(m_size.width) / rect.width;
         scale = min(scale, legibleScale);
         scale = clampPageScaleFactorToLimits(scale);
 
         scaleUnchanged = fabs(pageScaleFactor() - scale) < minScaleDifference;
     }
 
     bool stillAtPreviousDoubleTapScale = (pageScaleFactor() == m_doubleTapZoomPageScaleFactor
-        && m_doubleTapZoomPageScaleFactor != m_minimumPageScaleFactor)
+        && m_doubleTapZoomPageScaleFactor != minimumPageScaleFactor())
         || m_doubleTapZoomPending;
     if (zoomType == DoubleTap && (rect.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale)) {
         // Zoom out to minimum scale.
-        scale = m_minimumPageScaleFactor;
+        scale = minimumPageScaleFactor();
         scroll = WebPoint(hitRect.x, hitRect.y);
         isAnchor = true;
     } else {
         // FIXME: If this is being called for auto zoom during find in page,
         // then if the user manually zooms in it'd be nice to preserve the
         // relative increase in zoom they caused (if they zoom out then it's ok
         // to zoom them back in again). This isn't compatible with our current
         // double-tap zoom strategy (fitting the containing block to the screen)
         // though.
 
@@ skipping 382 matching lines @@
 {
     if (mainFrameImpl() && mainFrameImpl()->frameView())
         mainFrameImpl()->frameView()->willStartLiveResize();
 
     Frame* frame = mainFrameImpl()->frame();
     WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
     if (pluginContainer)
         pluginContainer->willStartLiveResize();
 }
 
-IntSize WebViewImpl::scaledSize(float pageScaleFactor) const
-{
-    FloatSize scaledSize = IntSize(m_size);
-    scaledSize.scale(1 / pageScaleFactor);
-    return expandedIntSize(scaledSize);
-}
-
 WebSize WebViewImpl::size()
 {
     return m_size;
 }
 
 void WebViewImpl::resize(const WebSize& newSize)
 {
     if (m_shouldAutoResize || m_size == newSize)
         return;
 
     FrameView* view = mainFrameImpl()->frameView();
     if (!view)
         return;
 
     WebSize oldSize = m_size;
     float oldPageScaleFactor = pageScaleFactor();
     int oldContentsWidth = contentsSize().width();
 
     m_size = newSize;
 
     bool shouldAnchorAndRescaleViewport = settings()->viewportEnabled() && oldSize.width && oldContentsWidth;
     ViewportAnchor viewportAnchor(mainFrameImpl()->frame()->eventHandler());
     if (shouldAnchorAndRescaleViewport) {
         viewportAnchor.setAnchor(view->visibleContentRect(),
                                  FloatSize(viewportAnchorXCoord, viewportAnchorYCoord));
     }
 
-    ViewportArguments viewportArguments = mainFrameImpl()->frame()->document()->viewportArguments();
-    m_page->chrome()->client()->dispatchViewportPropertiesDidChange(viewportArguments);
+    // Set the fixed layout size from the viewport constraints before resizing.
+    updatePageDefinedPageScaleConstraints(mainFrameImpl()->frame()->document()->viewportArguments());
 
     WebDevToolsAgentPrivate* agentPrivate = devToolsAgentPrivate();
     if (agentPrivate)
         agentPrivate->webViewResized(newSize);
     if (!agentPrivate || !agentPrivate->metricsOverridden()) {
         WebFrameImpl* webFrame = mainFrameImpl();
         if (webFrame->frameView())
             webFrame->frameView()->resize(m_size);
     }
 
@@ skipping 1178 matching lines @@
 {
     return pow(textSizeMultiplierRatio, zoomLevel);
 }
 
 double WebView::zoomFactorToZoomLevel(double factor)
 {
     // Since factor = 1.2^level, level = log(factor) / log(1.2)
     return log(factor) / log(textSizeMultiplierRatio);
 }
 
-void WebViewImpl::setInitialPageScaleOverride(float initialPageScaleFactorOverride)
-{
-    if (m_initialPageScaleFactorOverride == initialPageScaleFactorOverride)
-        return;
-    m_initialPageScaleFactorOverride = initialPageScaleFactorOverride;
-    m_pageScaleFactorIsSet = false;
-    computePageScaleFactorLimits();
-}
-
 float WebViewImpl::pageScaleFactor() const
 {
     if (!page())
         return 1;
 
     return page()->pageScaleFactor();
 }
 
-bool WebViewImpl::isPageScaleFactorSet() const
+float WebViewImpl::clampPageScaleFactorToLimits(float scaleFactor) const
 {
-    return m_pageScaleFactorIsSet;
+    return m_pageScaleConstraintsSet.finalConstraints().clampToConstraints(scaleFactor);
 }
 
-float WebViewImpl::clampPageScaleFactorToLimits(float scaleFactor)
+IntPoint WebViewImpl::clampOffsetAtScale(const IntPoint& offset, float scale)
 {
-    return min(max(scaleFactor, m_minimumPageScaleFactor), m_maximumPageScaleFactor);
-}
+    FrameView* view = mainFrameImpl()->frameView();
+    if (!view)
+        return offset;
 
-IntPoint WebViewImpl::clampOffsetAtScale(const IntPoint& offset, float scale) const
-{
+    IntPoint maxScrollExtent(contentsSize().width() - view->scrollOrigin().x(), contentsSize().height() - view->scrollOrigin().y());
+    FloatSize scaledSize = view->unscaledVisibleContentSize();
+    scaledSize.scale(1 / scale);
+
     IntPoint clampedOffset = offset;
-    clampedOffset = clampedOffset.shrunkTo(IntPoint(contentsSize() - scaledSize(scale)));
-    clampedOffset.clampNegativeToZero();
+    clampedOffset = clampedOffset.shrunkTo(maxScrollExtent - expandedIntSize(scaledSize));
+    clampedOffset = clampedOffset.expandedTo(-view->scrollOrigin());
 
     return clampedOffset;
 }
 
-void WebViewImpl::setPageScaleFactorPreservingScrollOffset(float scaleFactor)
-{
-    scaleFactor = clampPageScaleFactorToLimits(scaleFactor);
-
-    IntPoint scrollOffset(mainFrame()->scrollOffset().width, mainFrame()->scrollOffset().height);
-    scrollOffset = clampOffsetAtScale(scrollOffset, scaleFactor);
-
-    setPageScaleFactor(scaleFactor, scrollOffset);
-}
-
 void WebViewImpl::setPageScaleFactor(float scaleFactor, const WebPoint& origin)
 {
     if (!page())
         return;
 
-    if (!scaleFactor)
-        scaleFactor = 1;
-
     IntPoint newScrollOffset = origin;
     scaleFactor = clampPageScaleFactorToLimits(scaleFactor);
     newScrollOffset = clampOffsetAtScale(newScrollOffset, scaleFactor);
 
-    Frame* frame = page()->mainFrame();
-    FrameView* view = frame->view();
-    IntPoint oldScrollOffset = view->scrollPosition();
+    page()->setPageScaleFactor(scaleFactor, newScrollOffset);
+}
 
-    // Adjust the page scale in two steps. First, without change to scroll
-    // position, and then with a user scroll to the desired position.
-    // We do this because Page::setPageScaleFactor calls
-    // FrameView::setScrollPosition which is a programmatic scroll
-    // and we need this method to perform only user scrolls.
-    page()->setPageScaleFactor(scaleFactor, oldScrollOffset);
-    if (newScrollOffset != oldScrollOffset)
-        updateMainFrameScrollPosition(newScrollOffset, false);
+void WebViewImpl::setPageScaleFactorPreservingScrollOffset(float scaleFactor)
+{
+    if (clampPageScaleFactorToLimits(scaleFactor) == pageScaleFactor())
+        return;
 
-    m_pageScaleFactorIsSet = true;
+    IntPoint scrollOffset(mainFrame()->scrollOffset().width, mainFrame()->scrollOffset().height);
+    setPageScaleFactor(scaleFactor, scrollOffset);
 }
 
 float WebViewImpl::deviceScaleFactor() const
 {
     if (!page())
         return 1;
 
     return page()->deviceScaleFactor();
 }
 
@@ skipping 44 matching lines @@
     m_maxAutoSize = maxSize;
     configureAutoResizeMode();
 }
 
 void WebViewImpl::disableAutoResizeMode()
 {
     m_shouldAutoResize = false;
     configureAutoResizeMode();
 }
 
+void WebViewImpl::setUserAgentPageScaleConstraints(PageScaleConstraints newConstraints)
+{
+    if (newConstraints == m_pageScaleConstraintsSet.userAgentConstraints())
+        return;
+
+    m_pageScaleConstraintsSet.setUserAgentConstraints(newConstraints);
+
+    if (!mainFrameImpl() || !mainFrameImpl()->frameView())
+        return;
+
+    mainFrameImpl()->frameView()->setNeedsLayout();
+}
+
+void WebViewImpl::setInitialPageScaleOverride(float initialPageScaleFactorOverride)
+{
+    PageScaleConstraints constraints = m_pageScaleConstraintsSet.userAgentConstraints();
+    constraints.initialScale = initialPageScaleFactorOverride;
+
+    if (constraints == m_pageScaleConstraintsSet.userAgentConstraints())
+        return;
+
+    m_pageScaleConstraintsSet.setNeedsReset(true);
+    setUserAgentPageScaleConstraints(constraints);
+}
+
 void WebViewImpl::setPageScaleFactorLimits(float minPageScale, float maxPageScale)
 {
-    if (minPageScale == m_pageDefinedMinimumPageScaleFactor && maxPageScale == m_pageDefinedMaximumPageScaleFactor)
+    PageScaleConstraints constraints = m_pageScaleConstraintsSet.userAgentConstraints();
+    constraints.minimumScale = minPageScale;
+    constraints.maximumScale = maxPageScale;
+    setUserAgentPageScaleConstraints(constraints);
+}
+
+void WebViewImpl::setIgnoreViewportTagScaleLimits(bool ignore)
+{
+    PageScaleConstraints constraints = m_pageScaleConstraintsSet.userAgentConstraints();
+    if (ignore) {
+        constraints.minimumScale = m_pageScaleConstraintsSet.defaultConstraints().minimumScale;
+        constraints.maximumScale = m_pageScaleConstraintsSet.defaultConstraints().maximumScale;
+    } else {
+        constraints.minimumScale = -1;
+        constraints.maximumScale = -1;
+    }
+    setUserAgentPageScaleConstraints(constraints);
+}
+
+void WebViewImpl::refreshPageScaleFactorAfterLayout()
+{
+    if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->view())
+        return;
+    FrameView* view = page()->mainFrame()->view();
+
+    updatePageDefinedPageScaleConstraints(mainFrameImpl()->frame()->document()->viewportArguments());
+    m_pageScaleConstraintsSet.computeFinalConstraints();
+
+    if (settings()->viewportEnabled()) {
+        int verticalScrollbarWidth = 0;
+        if (view->verticalScrollbar() && !view->verticalScrollbar()->isOverlayScrollbar())
+            verticalScrollbarWidth = view->verticalScrollbar()->width();
+        m_pageScaleConstraintsSet.adjustFinalConstraintsToContentsSize(m_size, contentsSize(), verticalScrollbarWidth);
+    }
+
+    float newPageScaleFactor = pageScaleFactor();
+    if (m_pageScaleConstraintsSet.needsReset() && m_pageScaleConstraintsSet.finalConstraints().initialScale != -1) {
+        newPageScaleFactor = m_pageScaleConstraintsSet.finalConstraints().initialScale;
+        m_pageScaleConstraintsSet.setNeedsReset(false);
+    }
+    setPageScaleFactorPreservingScrollOffset(newPageScaleFactor);
+
+    updateLayerTreeViewport();
+
+    // Relayout immediately to avoid violating the rule that needsLayout()
+    // isn't set at the end of a layout.
+    if (view->needsLayout())
+        view->layout();
+}
+
+void WebViewImpl::updatePageDefinedPageScaleConstraints(const ViewportArguments& arguments)
+{
+    if (!settings()->viewportEnabled() || !isFixedLayoutModeEnabled() || !page() || !m_size.width || !m_size.height)
         return;
 
-    m_pageDefinedMinimumPageScaleFactor = minPageScale;
-    m_pageDefinedMaximumPageScaleFactor = maxPageScale;
+    m_pageScaleConstraintsSet.updatePageDefinedConstraints(arguments, m_size, page()->settings()->layoutFallbackWidth());
 
-    if (settings()->viewportEnabled()) {
-        // If we're in viewport tag mode, we need to layout to obtain the latest
-        // contents size and compute the final limits.
-        FrameView* view = mainFrameImpl()->frameView();
-        if (view)
-            view->setNeedsLayout();
-    } else {
-        // Otherwise just compute the limits immediately.
-        computePageScaleFactorLimits();
-    }
-}
+    if (settingsImpl()->supportDeprecatedTargetDensityDPI())
+        m_pageScaleConstraintsSet.adjustPageDefinedConstraintsForAndroidWebView(arguments, m_size, page()->settings()->layoutFallbackWidth(), deviceScaleFactor(), page()->settings()->useWideViewport(), page()->settings()->loadWithOverviewMode());
 
-void WebViewImpl::setIgnoreViewportTagMaximumScale(bool flag)
-{
-    m_ignoreViewportTagMaximumScale = flag;
-
-    if (!page() || !page()->mainFrame())
-        return;
-
-    m_page->chrome()->client()->dispatchViewportPropertiesDidChange(page()->mainFrame()->document()->viewportArguments());
+    setFixedLayoutSize(flooredIntSize(m_pageScaleConstraintsSet.pageDefinedConstraints().layoutSize));
 }
 
 IntSize WebViewImpl::contentsSize() const
 {
     RenderView* root = page()->mainFrame()->contentRenderer();
     if (!root)
         return IntSize();
     return root->documentRect().size();
 }
 
-void WebViewImpl::computePageScaleFactorLimits()
-{
-    if (!mainFrame() || !page() || !page()->mainFrame() || !page()->mainFrame()->view())
-        return;
-
-    FrameView* view = page()->mainFrame()->view();
-
-    if (m_pageDefinedMinimumPageScaleFactor == -1 || m_pageDefinedMaximumPageScaleFactor == -1) {
-        m_minimumPageScaleFactor = minPageScaleFactor;
-        m_maximumPageScaleFactor = maxPageScaleFactor;
-    } else {
-        m_minimumPageScaleFactor = min(max(m_pageDefinedMinimumPageScaleFactor, minPageScaleFactor), maxPageScaleFactor);
-        m_maximumPageScaleFactor = max(min(m_pageDefinedMaximumPageScaleFactor, maxPageScaleFactor), minPageScaleFactor);
-    }
-
-    if (settings()->viewportEnabled()) {
-        if (!contentsSize().width() || !m_size.width)
-            return;
-
-        // When viewport tag is enabled, the scale needed to see the full
-        // content width is the default minimum.
-        int viewWidthNotIncludingScrollbars = m_size.width;
-        if (view->verticalScrollbar() && !view->verticalScrollbar()->isOverlayScrollbar())
-            viewWidthNotIncludingScrollbars -= view->verticalScrollbar()->width();
-        m_minimumPageScaleFactor = max(m_minimumPageScaleFactor, static_cast<float>(viewWidthNotIncludingScrollbars) / contentsSize().width());
-        m_maximumPageScaleFactor = max(m_minimumPageScaleFactor, m_maximumPageScaleFactor);
-        if (m_initialPageScaleFactorOverride != -1) {
-            m_minimumPageScaleFactor = min(m_minimumPageScaleFactor, m_initialPageScaleFactorOverride);
-            m_maximumPageScaleFactor = max(m_maximumPageScaleFactor, m_initialPageScaleFactorOverride);
-        }
-    }
-    ASSERT(m_minimumPageScaleFactor <= m_maximumPageScaleFactor);
-
-    // Initialize and/or clamp the page scale factor if needed.
-    float initialPageScaleFactor = m_initialPageScaleFactor;
-    if (!settings()->viewportEnabled())
-        initialPageScaleFactor = 1;
-    if (m_initialPageScaleFactorOverride != -1)
-        initialPageScaleFactor = m_initialPageScaleFactorOverride;
-    float newPageScaleFactor = pageScaleFactor();
-    if (!m_pageScaleFactorIsSet && initialPageScaleFactor != -1) {
-        newPageScaleFactor = initialPageScaleFactor;
-        m_pageScaleFactorIsSet = true;
-    }
-    newPageScaleFactor = clampPageScaleFactorToLimits(newPageScaleFactor);
-    if (m_layerTreeView)
-        m_layerTreeView->setPageScaleFactorAndLimits(newPageScaleFactor, m_minimumPageScaleFactor, m_maximumPageScaleFactor);
-    if (newPageScaleFactor != pageScaleFactor())
-        setPageScaleFactorPreservingScrollOffset(newPageScaleFactor);
-}
-
 float WebViewImpl::minimumPageScaleFactor() const
 {
-    return m_minimumPageScaleFactor;
+    return m_pageScaleConstraintsSet.finalConstraints().minimumScale;
 }
 
 float WebViewImpl::maximumPageScaleFactor() const
 {
-    return m_maximumPageScaleFactor;
+    return m_pageScaleConstraintsSet.finalConstraints().maximumScale;
 }
 
 void WebViewImpl::saveScrollAndScaleState()
 {
     m_savedPageScaleFactor = pageScaleFactor();
     m_savedScrollOffset = mainFrame()->scrollOffset();
 }
 
 void WebViewImpl::restoreScrollAndScaleState()
 {
@@ skipping 11 matching lines @@
 }
 
 void WebViewImpl::resetScrollAndScaleState()
 {
     page()->setPageScaleFactor(1, IntPoint());
 
     // Clear out the values for the current history item. This will prevent the history item from clobbering the
     // value determined during page scale initialization, which may be less than 1.
     page()->mainFrame()->loader()->history()->saveDocumentAndScrollState();
     page()->mainFrame()->loader()->history()->clearScrollPositionAndViewState();
-    m_pageScaleFactorIsSet = false;
+    m_pageScaleConstraintsSet.setNeedsReset(true);
 
     // Clobber saved scales and scroll offsets.
     if (FrameView* view = page()->mainFrame()->document()->view())
         view->cacheCurrentScrollPosition();
     resetSavedScrollAndScaleState();
 }
 
 WebSize WebViewImpl::fixedLayoutSize() const
 {
     if (!page())
@@ skipping 509 matching lines @@
     if (isNewNavigation)
         *isNewNavigation = m_observedNewNavigation;
 
 #ifndef NDEBUG
     ASSERT(!m_observedNewNavigation
         || m_page->mainFrame()->loader()->documentLoader() == m_newNavigationLoader);
     m_newNavigationLoader = 0;
 #endif
     m_observedNewNavigation = false;
     if (*isNewNavigation && !isNavigationWithinPage)
-        m_pageScaleFactorIsSet = false;
+        m_pageScaleConstraintsSet.setNeedsReset(true);
 
     // Make sure link highlight from previous page is cleared.
     m_linkHighlight.clear();
     m_gestureAnimation.clear();
     if (m_layerTreeView)
         m_layerTreeView->didStopFlinging();
     resetSavedScrollAndScaleState();
 }
 
 void WebViewImpl::layoutUpdated(WebFrameImpl* webframe)
 {
     if (!m_client || webframe != mainFrameImpl())
         return;
 
     if (m_shouldAutoResize && mainFrameImpl()->frame() && mainFrameImpl()->frame()->view()) {
         WebSize frameSize = mainFrameImpl()->frame()->view()->frameRect().size();
         if (frameSize != m_size) {
             m_size = frameSize;
             m_client->didAutoResize(m_size);
             sendResizeEventAndRepaint();
         }
     }
 
-    if (settings()->viewportEnabled()) {
-        if (!isPageScaleFactorSet()) {
-            // If the viewport tag failed to be processed earlier, we need
-            // to recompute it now.
-            ViewportArguments viewportArguments = mainFrameImpl()->frame()->document()->viewportArguments();
-            m_page->chrome()->client()->dispatchViewportPropertiesDidChange(viewportArguments);
-        }
-
-        // Contents size is an input to the page scale limits, so a good time to
-        // recalculate is after layout has occurred.
-        computePageScaleFactorLimits();
-
-        // Relayout immediately to avoid violating the rule that needsLayout()
-        // isn't set at the end of a layout.
-        FrameView* view = mainFrameImpl()->frameView();
-        if (view && view->needsLayout())
-            view->layout();
-    }
+    if (m_pageScaleConstraintsSet.constraintsDirty())
+        refreshPageScaleFactorAfterLayout();
 
     m_client->didUpdateLayout();
-
 }
 
 void WebViewImpl::didChangeContentsSize()
 {
+    m_pageScaleConstraintsSet.didChangeContentsSize(contentsSize(), pageScaleFactor());
 }
 
 void WebViewImpl::deviceOrPageScaleFactorChanged()
 {
     if (pageScaleFactor() && pageScaleFactor() != 1)
         enterForceCompositingMode(true);
+    m_pageScaleConstraintsSet.setNeedsReset(false);
     updateLayerTreeViewport();
 }
 
 bool WebViewImpl::useExternalPopupMenus()
 {
     return shouldUseExternalPopupMenus;
 }
 
 void WebViewImpl::setEmulatedTextZoomFactor(float textZoomFactor)
 {
@@ skipping 302 matching lines @@
         m_nonCompositedContentHost->setOpaque(!isTransparent());
 
         m_client->initializeLayerTreeView();
         m_layerTreeView = m_client->layerTreeView();
         if (m_layerTreeView) {
             m_layerTreeView->setRootLayer(*m_rootLayer);
 
             bool visible = page()->visibilityState() == PageVisibilityStateVisible;
             m_layerTreeView->setVisible(visible);
             m_layerTreeView->setDeviceScaleFactor(page()->deviceScaleFactor());
-            m_layerTreeView->setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor);
+            m_layerTreeView->setPageScaleFactorAndLimits(pageScaleFactor(), minimumPageScaleFactor(), maximumPageScaleFactor());
             m_layerTreeView->setHasTransparentBackground(isTransparent());
             updateLayerTreeViewport();
             m_client->didActivateCompositor(m_inputHandlerIdentifier);
             m_isAcceleratedCompositingActive = true;
             m_compositorCreationFailed = false;
             if (m_pageOverlays)
                 m_pageOverlays->update();
             m_layerTreeView->setShowFPSCounter(m_showFPSCounter);
             m_layerTreeView->setShowPaintRects(m_showPaintRects);
             m_layerTreeView->setShowDebugBorders(m_showDebugBorders);
@@ skipping 68 matching lines @@
         m_pageOverlays->update();
 }
 
 void WebViewImpl::updateLayerTreeViewport()
 {
     if (!page() || !m_nonCompositedContentHost || !m_layerTreeView)
         return;
 
     FrameView* view = page()->mainFrame()->view();
     m_nonCompositedContentHost->setViewport(m_size, view->contentsSize(), view->scrollPosition(), view->scrollOrigin());
-    m_layerTreeView->setPageScaleFactorAndLimits(pageScaleFactor(), m_minimumPageScaleFactor, m_maximumPageScaleFactor);
+    m_layerTreeView->setPageScaleFactorAndLimits(pageScaleFactor(), minimumPageScaleFactor(), maximumPageScaleFactor());
 }
 
 void WebViewImpl::selectAutofillSuggestionAtIndex(unsigned listIndex)
 {
     if (m_autofillPopupClient && listIndex < m_autofillPopupClient->getSuggestionsCount())
         m_autofillPopupClient->valueChanged(listIndex);
 }
 
 bool WebViewImpl::detectContentOnTouch(const WebPoint& position)
 {
@@ skipping 85 matching lines @@
 }
 
 bool WebViewImpl::shouldDisableDesktopWorkarounds()
 {
     ViewportArguments arguments = mainFrameImpl()->frame()->document()->viewportArguments();
     return arguments.width == ViewportArguments::ValueDeviceWidth || !arguments.userZoom
         || (arguments.minZoom == arguments.maxZoom && arguments.minZoom != ViewportArguments::ValueAuto);
 }
 
 } // namespace WebKit