Scale to legibleScale if double tap would barely zoom in from zoomed out state.

Source/web/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 1106 matching lines @@
 
     const int newWidth = source.width + leftMargin + rightMargin;
     const int newX = source.x - leftMargin;
 
     ASSERT(newWidth >= 0);
     ASSERT(scrollOffset.width() + newX + newWidth <= maxSize.width);
 
     return WebRect(newX, source.y, newWidth, source.height);
 }
 
-void WebViewImpl::computeScaleAndScrollForBlockRect(const WebRect& blockRect, float padding, float& scale, WebPoint& scroll, bool& doubleTapShouldZoomOut)
+float WebViewImpl::computeLegibleScale()
+{
+    // 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 = minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
+    float legibleScale = 1;
+    if (page())
+        legibleScale *= page()->settings().textAutosizingFontScaleFactor();
+    if (legibleScale < defaultScaleWhenAlreadyLegible)

[aelias_OOO_until_Jul13, 2013/08/29 00:19:32]

Delete these two lines.

+        legibleScale = (pageScaleFactor() == minimumPageScaleFactor()) ? defaultScaleWhenAlreadyLegible : minimumPageScaleFactor();
+    return legibleScale;
+}
+
+void WebViewImpl::computeScaleAndScrollForBlockRect(const WebRect& blockRect, float padding, float& scale, WebPoint& scroll)

[aelias_OOO_until_Jul13, 2013/08/29 00:19:32]

Come to think of it, the defaultScaleWhenAlreadyLegible logic makes no sense for
other uses like find-in-page anyway.  I suggest passing a new argument
defaultScaleWhenAlreadyLegible here.  For double-taps it would be the current
value minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio, and for other
uses it would be minimumPageScaleFactor().

 {
     scale = pageScaleFactor();
     scroll.x = scroll.y = 0;
 
     WebRect rect = blockRect;
 
-    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 = minimumPageScaleFactor() * doubleTapZoomAlreadyLegibleRatio;
-        float legibleScale = 1;
-        if (page())
-            legibleScale *= page()->settings().textAutosizingFontScaleFactor();
-        if (legibleScale < defaultScaleWhenAlreadyLegible)
-            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 = min(scale, computeLegibleScale());

[aelias_OOO_until_Jul13, 2013/08/29 00:19:32]

Immediately after this line add the lines:

if (pageScaleFactor() < defaultScaleWhenAlreadyLegible)
  scale = max(scale, defaultScaleWhenAlreadyLegible);

         scale = clampPageScaleFactorToLimits(scale);
-
-        scaleUnchanged = fabs(pageScaleFactor() - scale) < minScaleDifference;
     }
 
-    bool stillAtPreviousDoubleTapScale = (pageScaleFactor() == m_doubleTapZoomPageScaleFactor
-        && m_doubleTapZoomPageScaleFactor != minimumPageScaleFactor())
-        || m_doubleTapZoomPending;
-
-    doubleTapShouldZoomOut = rect.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale;

[aelias_OOO_until_Jul13, 2013/08/29 00:19:32]

Good idea, there was no reason to keep this in this method.

-
     // 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.
 
     float screenWidth = m_size.width / scale;
     float screenHeight = m_size.height / scale;
 
     // Scroll to vertically align the block.
     if (rect.height < screenHeight) {
         // Vertically center short blocks.
         rect.y -= 0.5 * (screenHeight - rect.height);
     } else {
         // Ensure position we're zooming to (+ padding) isn't off the bottom of
         // the screen.
         rect.y = max<float>(rect.y, blockRect.y + padding - screenHeight);
     } // Otherwise top align the block.
 
     // Do the same thing for horizontal alignment.
     if (rect.width < screenWidth)
         rect.x -= 0.5 * (screenWidth - rect.width);
     else
         rect.x = max<float>(rect.x, blockRect.x + padding - screenWidth);
     scroll.x = rect.x;
     scroll.y = rect.y;
 
-    scale = clampPageScaleFactorToLimits(scale);
     scroll = mainFrameImpl()->frameView()->windowToContents(scroll);
     scroll = clampOffsetAtScale(scroll, scale);

[aelias_OOO_until_Jul13, 2013/08/29 00:19:32]

The amount of scaling must be finalized before this point or this clamp will not
work properly.

 }
 
 static bool invokesHandCursor(Node* node, bool shiftKey, Frame* frame)
 {
     if (!node || !node->renderer())
         return false;
 
     ECursor cursor = node->renderer()->style()->cursor();
     return cursor == CURSOR_POINTER
         || (cursor == CURSOR_AUTO && frame->eventHandler()->useHandCursor(node, node->isLink(), shiftKey));
@@ skipping 48 matching lines @@
 void WebViewImpl::animateDoubleTapZoom(const IntPoint& point)
 {
     if (!mainFrameImpl())
         return;
 
     WebRect rect(point.x(), point.y(), touchPointPadding, touchPointPadding);
     WebRect blockBounds = computeBlockBounds(rect, false);
 
     float scale;
     WebPoint scroll;
-    bool doubleTapShouldZoomOut;
 
-    computeScaleAndScrollForBlockRect(blockBounds, touchPointPadding, scale, scroll, doubleTapShouldZoomOut);
+    computeScaleAndScrollForBlockRect(blockBounds, touchPointPadding, scale, scroll);
+
+    bool stillAtPreviousDoubleTapScale = (pageScaleFactor() == m_doubleTapZoomPageScaleFactor
+        && m_doubleTapZoomPageScaleFactor != minimumPageScaleFactor())
+        || m_doubleTapZoomPending;
+
+    bool scaleUnchanged = fabs(pageScaleFactor() - scale) < minScaleDifference;
+    bool shouldZoomOut = blockBounds.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale;
+
+    if ((blockBounds.isEmpty() || scaleUnchanged) && fabs(scale - minimumPageScaleFactor()) < minScaleDifference) {

[aelias_OOO_until_Jul13, 2013/08/29 00:19:32]

Delete this block.

+        scale = computeLegibleScale();
+        shouldZoomOut = false;
+    }
 
     bool isAnimating;
 
-    if (doubleTapShouldZoomOut) {
+    if (shouldZoomOut) {
         scale = minimumPageScaleFactor();
         isAnimating = startPageScaleAnimation(mainFrameImpl()->frameView()->windowToContents(point), true, scale, doubleTapZoomAnimationDurationInSeconds);
     } else {
         isAnimating = startPageScaleAnimation(scroll, false, scale, doubleTapZoomAnimationDurationInSeconds);
     }
 
     if (isAnimating) {
         m_doubleTapZoomPageScaleFactor = scale;
         m_doubleTapZoomPending = true;
     }
 }
 
 void WebViewImpl::zoomToFindInPageRect(const WebRect& rect)
 {
     if (!mainFrameImpl())
         return;
 
     WebRect blockBounds = computeBlockBounds(rect, true);
 
     if (blockBounds.isEmpty()) {
         // Keep current scale (no need to scroll as x,y will normally already
         // be visible). FIXME: Revisit this if it isn't always true.
         return;
     }
 
     float scale;
     WebPoint scroll;
-    bool doubleTapShouldZoomOut;
 
-    computeScaleAndScrollForBlockRect(blockBounds, nonUserInitiatedPointPadding, scale, scroll, doubleTapShouldZoomOut);
+    computeScaleAndScrollForBlockRect(blockBounds, nonUserInitiatedPointPadding, scale, scroll);
 
     startPageScaleAnimation(scroll, false, scale, findInPageAnimationDurationInSeconds);
 }
 
 bool WebViewImpl::zoomToMultipleTargetsRect(const WebRect& rect)
 {
     if (!mainFrameImpl())
         return false;
 
     float scale;
     WebPoint scroll;
-    bool doubleTapShouldZoomOut;
 
-    computeScaleAndScrollForBlockRect(rect, nonUserInitiatedPointPadding, scale, scroll, doubleTapShouldZoomOut);
+    computeScaleAndScrollForBlockRect(rect, nonUserInitiatedPointPadding, scale, scroll);
 
     if (scale <= pageScaleFactor())
         return false;
 
     startPageScaleAnimation(scroll, false, scale, multipleTargetsZoomAnimationDurationInSeconds);
     return true;
 }
 
 void WebViewImpl::numberOfWheelEventHandlersChanged(unsigned numberOfWheelHandlers)
 {
@@ skipping 2779 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