Allow zoom-in to a target rect when tapping multiple targets.

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 172 matching lines @@
 // (such as due to a double tap gesture or find in page etc.). These are
 // experimentally determined.
 static const int touchPointPadding = 32;
 static const int nonUserInitiatedPointPadding = 11;
 static const float minScaleDifference = 0.01f;
 static const float doubleTapZoomContentDefaultMargin = 5;
 static const float doubleTapZoomContentMinimumMargin = 2;
 static const double doubleTapZoomAnimationDurationInSeconds = 0.25;
 static const float doubleTapZoomAlreadyLegibleRatio = 1.2f;
 
+static const double multipleTargetsZoomAnimationDurationInSeconds = 0.25;
+static const double findInPageAnimationDurationInSeconds = 0;
+
 // Constants for viewport anchoring on resize.
 static const float viewportAnchorXCoord = 0.5f;
 static const float viewportAnchorYCoord = 0;
 
 // Constants for zooming in on a focused text field.
 static const double scrollAndScaleAnimationDurationInSeconds = 0.2;
 static const int minReadableCaretHeight = 18;
 static const float minScaleChangeToTriggerZoom = 1.05f;
 static const float leftBoxRatio = 0.3f;
 static const int caretPadding = 10;
@@ skipping 173 matching lines @@
 #ifndef NDEBUG
     , m_newNavigationLoader(0)
 #endif
     , m_zoomLevel(0)
     , m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier))
     , m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier))
     , m_savedPageScaleFactor(0)
     , m_exitFullscreenPageScaleFactor(0)
     , m_doubleTapZoomPageScaleFactor(0)
     , m_doubleTapZoomPending(false)
-    , m_enableFakeDoubleTapAnimationForTesting(false)
-    , m_fakeDoubleTapPageScaleFactor(0)
-    , m_fakeDoubleTapUseAnchor(false)
+    , m_enableFakePageScaleAnimationForTesting(false)
+    , m_fakePageScaleAnimationPageScaleFactor(0)
+    , m_fakePageScaleAnimationUseAnchor(false)
     , m_contextMenuAllowed(false)
     , m_doingDragAndDrop(false)
     , m_ignoreInputEvents(false)
     , m_suppressNextKeypressEvent(false)
     , m_imeAcceptEvents(true)
     , m_operationsAllowed(WebDragOperationNone)
     , m_dragOperation(WebDragOperationNone)
     , m_featureSwitchClient(adoptPtr(new ContextFeaturesClientImpl()))
     , m_autofillPopupShowing(false)
     , m_autofillPopup(0)
@@ skipping 367 matching lines @@
         break;
     }
     case WebInputEvent::GestureTapDown: {
         m_client->cancelScheduledContentIntents();
         eventSwallowed = mainFrameImpl()->frame()->eventHandler()->handleGestureEvent(platformEvent);
         break;
     }
     case WebInputEvent::GestureDoubleTap:
         if (m_webSettings->doubleTapToZoomEnabled() && minimumPageScaleFactor() != maximumPageScaleFactor()) {
             m_client->cancelScheduledContentIntents();
-            animateZoomAroundPoint(platformEvent.position(), DoubleTap);
+            animateDoubleTapZoom(platformEvent.position());
         }
         // 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();
     case WebInputEvent::GestureScrollEnd:
     case WebInputEvent::GestureScrollUpdate:
@@ skipping 30 matching lines @@
     if (!useAnchor) {
         clampedPoint = clampOffsetAtScale(targetPosition, newScale);
         if (!durationInSeconds) {
             setPageScaleFactor(newScale, clampedPoint);
             return false;
         }
     }
     if (useAnchor && newScale == pageScaleFactor())
         return false;
 
-    if (m_enableFakeDoubleTapAnimationForTesting) {
-        m_fakeDoubleTapTargetPosition = targetPosition;
-        m_fakeDoubleTapUseAnchor = useAnchor;
-        m_fakeDoubleTapPageScaleFactor = newScale;
+    if (m_enableFakePageScaleAnimationForTesting) {
+        m_fakePageScaleAnimationTargetPosition = targetPosition;
+        m_fakePageScaleAnimationUseAnchor = useAnchor;
+        m_fakePageScaleAnimationPageScaleFactor = newScale;
     } else {
         if (!m_layerTreeView)
             return false;
         m_layerTreeView->startPageScaleAnimation(targetPosition, useAnchor, newScale, durationInSeconds);
     }
     return true;
 }
 
-void WebViewImpl::enableFakeDoubleTapAnimationForTesting(bool enable)
+void WebViewImpl::enableFakePageScaleAnimationForTesting(bool enable)
 {
-    m_enableFakeDoubleTapAnimationForTesting = enable;
+    m_enableFakePageScaleAnimationForTesting = enable;
 }
 
 WebViewBenchmarkSupport* WebViewImpl::benchmarkSupport()
 {
     return &m_benchmarkSupport;
 }
 
 void WebViewImpl::setShowFPSCounter(bool show)
 {
     if (m_layerTreeView) {
@@ skipping 206 matching lines @@
     // events.
     if (evt.isSystemKey())
         return false;
 
     if (!suppress && !handler->keyEvent(evt))
         return keyEventDefault(event);
 
     return true;
 }
 
-WebRect WebViewImpl::computeBlockBounds(const WebRect& rect, AutoZoomType zoomType)
+WebRect WebViewImpl::computeBlockBounds(
+    const WebRect& rect,
+    bool ignoreClipping)
 {
     if (!mainFrameImpl())
         return WebRect();
 
     // Use the rect-based hit test to find the node.
     IntPoint point = mainFrameImpl()->frameView()->windowToContents(IntPoint(rect.x, rect.y));
-    HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent
-            | ((zoomType == FindInPage) ? HitTestRequest::IgnoreClipping : 0);
+    HitTestRequest::HitTestRequestType hitType =
+        HitTestRequest::ReadOnly |
+        HitTestRequest::Active |
+        HitTestRequest::DisallowShadowContent |
+        (ignoreClipping ? HitTestRequest::IgnoreClipping : 0);
     HitTestResult result = mainFrameImpl()->frame()->eventHandler()->hitTestResultAtPoint(point, hitType, IntSize(rect.width, rect.height));
 
     Node* node = result.innerNonSharedNode();
     if (!node)
         return WebRect();
 
     // Find the block type node based on the hit node.
     while (node && (!node->renderer() || node->renderer()->isInline()))
         node = node->parentNode();
 
@@ skipping 31 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::computeScaleAndScrollForHitRect(const WebRect& hitRect, AutoZoomType zoomType, float& scale, WebPoint& scroll, bool& isAnchor)
+void WebViewImpl::computeScaleAndScrollForHitRect(
+    const WebRect& hitRect,

[aelias_OOO_until_Jul13, 2013/07/27 05:59:24]

Since this doesn't really take a hitrect anymore, rename to
"computeScaleAndScrollForBlockRect"/ const WebRect& blockRect.

+    float padding,
+    float& scale,
+    WebPoint& scroll,
+    bool& doubleTapShouldZoomOut)
 {
     scale = pageScaleFactor();
     scroll.x = scroll.y = 0;
-    WebRect targetRect = hitRect;
-    // Padding only depends on page scale when triggered by manually tapping
-    int padding = (zoomType == DoubleTap) ? touchPointPadding : nonUserInitiatedPointPadding;
-    if (targetRect.isEmpty())
-        targetRect.width = targetRect.height = padding;
-    WebRect rect = computeBlockBounds(targetRect, zoomType);
-    if (zoomType == FindInPage && rect.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;
-    }
+
+    WebRect rect = hitRect;
 
     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() && page()->settings())
@@ skipping 16 matching lines @@
         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 != minimumPageScaleFactor())
         || m_doubleTapZoomPending;
-    if (zoomType == DoubleTap && (rect.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale)) {
-        // Zoom out to minimum scale.
-        scale = minimumPageScaleFactor();
-        scroll = WebPoint(hitRect.x, hitRect.y);
-        isAnchor = true;
+
+    doubleTapShouldZoomOut =
+        rect.isEmpty() || scaleUnchanged || stillAtPreviousDoubleTapScale;
+
+    // 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 {
-        // 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.
+        // Ensure position we're zooming to (+ padding) isn't off the bottom of
+        // the screen.
+        rect.y = max<float>(rect.y, hitRect.y + padding - screenHeight);
+    } // Otherwise top align the block.
 
-        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, hitRect.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, hitRect.x + padding - screenWidth);
-        scroll.x = rect.x;
-        scroll.y = rect.y;
-        isAnchor = false;
-    }
+    // 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, hitRect.x + padding - screenWidth);
+    scroll.x = rect.x;
+    scroll.y = rect.y;
 
     scale = clampPageScaleFactorToLimits(scale);
     scroll = mainFrameImpl()->frameView()->windowToContents(scroll);
-    if (!isAnchor)
-        scroll = clampOffsetAtScale(scroll, scale);

[aelias_OOO_until_Jul13, 2013/07/27 05:59:24]

This line should still be there since we want to maintain the behavior when
isAnchor is false.

 }
 
 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 38 matching lines @@
     Color highlightColor = touchNode->renderer()->style()->tapHighlightColor();
     // Safari documentation for -webkit-tap-highlight-color says if the specified color has 0 alpha,
     // then tap highlighting is disabled.
     // http://developer.apple.com/library/safari/#documentation/appleapplications/reference/safaricssref/articles/standardcssproperties.html
     if (!highlightColor.alpha())
         return;
 
     m_linkHighlight = LinkHighlight::create(touchNode, this);
 }
 
-void WebViewImpl::animateZoomAroundPoint(const IntPoint& point, AutoZoomType zoomType)
+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 isAnchor;
-    WebPoint webPoint = point;
-    computeScaleAndScrollForHitRect(WebRect(webPoint.x, webPoint.y, 0, 0), zoomType, scale, scroll, isAnchor);
+    bool doubleTapShouldZoomOut;
 
-    bool isDoubleTap = (zoomType == DoubleTap);
-    double durationInSeconds = isDoubleTap ? doubleTapZoomAnimationDurationInSeconds : 0;
-    bool isAnimating = startPageScaleAnimation(scroll, isAnchor, scale, durationInSeconds);
+    computeScaleAndScrollForHitRect(
+        blockBounds, touchPointPadding, scale, scroll, doubleTapShouldZoomOut);
 
-    if (isDoubleTap && isAnimating) {
+    bool isAnimating;
+
+    if (doubleTapShouldZoomOut) {
+        isAnimating = startPageScaleAnimation(
+            mainFrameImpl()->frameView()->windowToContents(point),
+            true,
+            minimumPageScaleFactor(),
+            doubleTapZoomAnimationDurationInSeconds);
+    } else {
+        isAnimating = startPageScaleAnimation(
+            scroll, false, scale, doubleTapZoomAnimationDurationInSeconds);
+    }
+
+    if (isAnimating) {
         m_doubleTapZoomPageScaleFactor = scale;
         m_doubleTapZoomPending = true;
     }
 }
 
 void WebViewImpl::zoomToFindInPageRect(const WebRect& rect)
 {
-    animateZoomAroundPoint(IntRect(rect).center(), FindInPage);
+    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;
+
+    computeScaleAndScrollForHitRect(blockBounds, nonUserInitiatedPointPadding,
+        scale, scroll, doubleTapShouldZoomOut);
+
+    startPageScaleAnimation(
+        scroll, false, scale, findInPageAnimationDurationInSeconds);
+}
+
+bool WebViewImpl::zoomToMultipleTargetsRect(const WebRect& rect)
+{
+    if (!mainFrameImpl())
+        return false;
+
+    float scale;
+    WebPoint scroll;
+    bool doubleTapShouldZoomOut;
+
+    computeScaleAndScrollForHitRect(rect, nonUserInitiatedPointPadding,
+        scale, scroll, doubleTapShouldZoomOut);
+
+    if (scale <= pageScaleFactor())
+        return false;
+
+    startPageScaleAnimation(
+        scroll, false, scale, multipleTargetsZoomAnimationDurationInSeconds);
+    return true;
 }
 
 void WebViewImpl::numberOfWheelEventHandlersChanged(unsigned numberOfWheelHandlers)
 {
     if (m_client)
         m_client->numberOfWheelEventHandlersChanged(numberOfWheelHandlers);
 }
 
 void WebViewImpl::hasTouchEventHandlers(bool hasTouchHandlers)
 {
@@ skipping 2848 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