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

Source/web/WebViewImpl.h

 /*
  * Copyright (C) 2010 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 109 matching lines @@
 class WebSettingsImpl;
 class WebTouchEvent;
 class WebViewBenchmarkSupport;
 
 class WebViewImpl : public WebView
     , public RefCounted<WebViewImpl>
     , public WebGestureCurveTarget
     , public WebCore::PagePopupDriver
     , public PageWidgetEventHandler {
 public:
-    enum AutoZoomType {
-        DoubleTap,
-        FindInPage,
-    };
 
     // WebWidget methods:
     virtual void close();
     virtual WebSize size();
     virtual void willStartLiveResize();
     virtual void resize(const WebSize&);
     virtual void willEndLiveResize();
     virtual void willEnterFullScreen();
     virtual void didEnterFullScreen();
     virtual void willExitFullScreen();
@@ skipping 72 matching lines @@
     virtual void clearFocusedNode();
     virtual void scrollFocusedNodeIntoView();
     virtual void scrollFocusedNodeIntoRect(const WebRect&);
     virtual void zoomToFindInPageRect(const WebRect&);
     virtual void advanceFocus(bool reverse);
     virtual double zoomLevel();
     virtual double setZoomLevel(bool textOnly, double zoomLevel);
     virtual void zoomLimitsChanged(double minimumZoomLevel,
                                    double maximumZoomLevel);
     virtual void setInitialPageScaleOverride(float);
+    virtual bool zoomToMultipleTargetsRect(const WebRect&);
     virtual float pageScaleFactor() const;
     virtual void setPageScaleFactorPreservingScrollOffset(float);
     virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin);
     virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale);
     virtual float minimumPageScaleFactor() const;
     virtual float maximumPageScaleFactor() const;
     virtual void saveScrollAndScaleState();
     virtual void restoreScrollAndScaleState();
     virtual void resetScrollAndScaleState();
     virtual void setIgnoreViewportTagScaleLimits(bool);
@@ skipping 281 matching lines @@
     static bool mapKeyCodeForScroll(int keyCode,
                                    WebCore::ScrollDirection* scrollDirection,
                                    WebCore::ScrollGranularity* scrollGranularity);
 
     // Called by a full frame plugin inside this view to inform it that its
     // zoom level has been updated.  The plugin should only call this function
     // if the zoom change was triggered by the browser, it's only needed in case
     // a plugin can update its own zoom, say because of its own UI.
     void fullFramePluginZoomLevelChanged(double zoomLevel);
 
-    void computeScaleAndScrollForHitRect(const WebRect& hitRect, AutoZoomType, float& scale, WebPoint& scroll, bool& isAnchor);
+    void computeScaleAndScrollForBlockRect(

[jochen (gone - plz use gerrit), 2013/07/30 06:41:11]

no need to wrap here

+        const WebRect& blockRect,
+        float padding,
+        float& scale,
+        WebPoint& scroll,
+        bool& doubleTapShouldZoomOut);
     WebCore::Node* bestTapNode(const WebCore::PlatformGestureEvent& tapEvent);
     void enableTapHighlight(const WebCore::PlatformGestureEvent& tapEvent);
     void computeScaleAndScrollForFocusedNode(WebCore::Node* focusedNode, float& scale, WebCore::IntPoint& scroll, bool& needAnimation);
-    void animateZoomAroundPoint(const WebCore::IntPoint&, AutoZoomType);
 
-    void enableFakeDoubleTapAnimationForTesting(bool);
-    bool fakeDoubleTapAnimationPendingForTesting() const { return m_doubleTapZoomPending; }
-    WebCore::IntPoint fakeDoubleTapTargetPositionForTesting() const { return m_fakeDoubleTapTargetPosition; }
-    float fakeDoubleTapPageScaleFactorForTesting() const { return m_fakeDoubleTapPageScaleFactor; }
-    bool fakeDoubleTapUseAnchorForTesting() const { return m_fakeDoubleTapUseAnchor; }
+    void animateDoubleTapZoom(const WebCore::IntPoint&);
+    bool animateZoomToRect(

[jochen (gone - plz use gerrit), 2013/07/30 06:41:11]

nor here

+        const WebCore::IntRect&,
+        double durationInSeconds,
+        bool& isAnimating,
+        float& scale);
+
+    void enableFakePageScaleAnimationForTesting(bool);
+    bool fakeDoubleTapAnimationPendingForTesting() const

[jochen (gone - plz use gerrit), 2013/07/30 06:41:11]

can also fit on one line (and below)

+    {
+        return m_doubleTapZoomPending;
+    }
+    WebCore::IntPoint fakePageScaleAnimationTargetPositionForTesting() const
+    {
+        return m_fakePageScaleAnimationTargetPosition;
+    }
+    float fakePageScaleAnimationPageScaleForTesting() const
+    {
+        return m_fakePageScaleAnimationPageScaleFactor;
+    }
+    bool fakePageScaleAnimationUseAnchorForTesting() const
+    {
+        return m_fakePageScaleAnimationUseAnchor;
+    }
 
     void enterFullScreenForElement(WebCore::Element*);
     void exitFullScreenForElement(WebCore::Element*);
 
     // Exposed for the purpose of overriding device metrics.
     void sendResizeEventAndRepaint();
 
     // Exposed for testing purposes.
     bool hasHorizontalScrollbar();
     bool hasVerticalScrollbar();
 
     // Pointer Lock calls allow a page to capture all mouse events and
     // disable the system cursor.
     virtual bool requestPointerLock();
     virtual void requestPointerUnlock();
     virtual bool isPointerLocked();
 
     // Heuristic-based function for determining if we should disable workarounds
     // for viewing websites that are not optimized for mobile devices.
     bool shouldDisableDesktopWorkarounds();
 
     // Exposed for tests.
     LinkHighlight* linkHighlight() { return m_linkHighlight.get(); }
 
     WebSettingsImpl* settingsImpl();
 
+    // Returns the bounding box of the block type node touched by the WebRect.
+    WebRect computeBlockBounds(const WebRect&, bool ignoreClipping);
+
+    WebCore::IntPoint clampOffsetAtScale(
+        const WebCore::IntPoint& offset,
+        float scale);
+
 private:
     void refreshPageScaleFactorAfterLayout();
     void setUserAgentPageScaleConstraints(WebCore::PageScaleConstraints newConstraints);
     float clampPageScaleFactorToLimits(float) const;
-    WebCore::IntPoint clampOffsetAtScale(const WebCore::IntPoint& offset, float scale);
     WebCore::IntSize contentsSize() const;
 
     void resetSavedScrollAndScaleState();
 
     void updateMainFrameScrollPosition(const WebCore::IntPoint& scrollPosition, bool programmaticScroll);
 
     friend class WebView;  // So WebView::Create can call our constructor
     friend class WTF::RefCounted<WebViewImpl>;
     friend void setCurrentInputEventForTest(const WebInputEvent*);
 
@@ skipping 40 matching lines @@
                                                int keyModifiers);
 
     void configureAutoResizeMode();
 
     void setIsAcceleratedCompositingActive(bool);
     void doComposite();
     void doPixelReadbackToCanvas(WebCanvas*, const WebCore::IntRect&);
     void reallocateRenderer();
     void updateLayerTreeViewport();
 
-    // Returns the bounding box of the block type node touched by the WebRect.
-    WebRect computeBlockBounds(const WebRect&, AutoZoomType);
-
     // Helper function: Widens the width of |source| by the specified margins
     // while keeping it smaller than page width.
     WebRect widenRectWithinPageBounds(const WebRect& source, int targetMargin, int minimumMargin);
 
     void pointerLockMouseEvent(const WebInputEvent&);
 
     // PageWidgetEventHandler functions
     virtual void handleMouseLeave(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
     virtual void handleMouseDown(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
     virtual void handleMouseUp(WebCore::Frame&, const WebMouseEvent&) OVERRIDE;
@@ skipping 66 matching lines @@
     WebCore::IntSize m_savedScrollOffset;
     float m_exitFullscreenPageScaleFactor;
     WebCore::IntSize m_exitFullscreenScrollOffset;
 
     // The scale moved to by the latest double tap zoom, if any.
     float m_doubleTapZoomPageScaleFactor;
     // Have we sent a double-tap zoom and not yet heard back the scale?
     bool m_doubleTapZoomPending;
 
     // Used for testing purposes.
-    bool m_enableFakeDoubleTapAnimationForTesting;
-    WebCore::IntPoint m_fakeDoubleTapTargetPosition;
-    float m_fakeDoubleTapPageScaleFactor;
-    bool m_fakeDoubleTapUseAnchor;
+    bool m_enableFakePageScaleAnimationForTesting;
+    WebCore::IntPoint m_fakePageScaleAnimationTargetPosition;
+    float m_fakePageScaleAnimationPageScaleFactor;
+    bool m_fakePageScaleAnimationUseAnchor;
 
     bool m_contextMenuAllowed;
 
     bool m_doingDragAndDrop;
 
     bool m_ignoreInputEvents;
 
     // Webkit expects keyPress events to be suppressed if the associated keyDown
     // event was handled. Safari implements this behavior by peeking out the
     // associated WM_CHAR event if the keydown was handled. We emulate
@@ skipping 100 matching lines @@
     bool m_showFPSCounter;
     bool m_showPaintRects;
     bool m_showDebugBorders;
     bool m_continuousPaintingEnabled;
     bool m_showScrollBottleneckRects;
 };
 
 } // namespace WebKit
 
 #endif