[Pinch-to-zoom] Moved scale factor into PinchViewport

public/web/WebView.h

 /*
  * Copyright (C) 2009, 2010, 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 46 matching lines @@
 class WebRange;
 class WebSettings;
 class WebSpellCheckClient;
 class WebString;
 class WebPasswordGeneratorClient;
 class WebViewClient;
 struct WebActiveWheelFlingParameters;
 struct WebMediaPlayerAction;
 struct WebPluginAction;
 struct WebPoint;
+struct WebFloatPoint;
 struct WebWindowFeatures;
 
 class WebView : public WebWidget {
 public:
     BLINK_EXPORT static const double textSizeMultiplierRatio;
     BLINK_EXPORT static const double minTextSizeMultiplier;
     BLINK_EXPORT static const double maxTextSizeMultiplier;
     BLINK_EXPORT static const float minPageScaleFactor;
     BLINK_EXPORT static const float maxPageScaleFactor;
 
@@ skipping 146 matching lines @@
     virtual float textZoomFactor() = 0;
 
     // Scales the text in the page by a factor of textZoomFactor.
     // Note: this has no effect on plugins.
     virtual float setTextZoomFactor(float) = 0;
 
     // Sets the initial page scale to the given factor. This scale setting overrides
     // page scale set in the page's viewport meta tag.
     virtual void setInitialPageScaleOverride(float) = 0;
 
+    // TODO: Remove once all uses are converted to the "PinchViewport" methods below.
     // Gets the scale factor of the page, where 1.0 is the normal size, > 1.0
     // is scaled up, < 1.0 is scaled down.
     virtual float pageScaleFactor() const = 0;
 
-    // Scales the page and the scroll offset by a given factor, while ensuring
-    // that the new scroll position does not go beyond the edge of the page.
-    virtual void setPageScaleFactorPreservingScrollOffset(float) = 0;
-
+    // TODO: Remove once all uses are converted to the "PinchViewport" methods below.
     // Scales a page by a factor of scaleFactor and then sets a scroll position to (x, y).
     // setPageScaleFactor() magnifies and shrinks a page without affecting layout.
     // On the other hand, zooming affects layout of the page.
     virtual void setPageScaleFactor(float scaleFactor, const WebPoint& origin) = 0;
 
+    // TODO: Remove once all uses are converted to the "PinchViewport" methods below.
+    // Temporary to keep old style pinch viewport working while we gradually bring up
+    // virtual viewport pinch.
+    virtual void setMainFrameScrollOffset(const WebPoint& origin) = 0;
+
+    // Scales the page without affecting layout by using the pinch-to-zoom viewport.
+    virtual void setPinchViewportScaleFactor(float) = 0;

[aelias_OOO_until_Jul13, 2014/04/10 16:23:49]

On second thought, I would suggest that you not change the name of
"PageScaleFactor" here.  The most important thing is to keep the name of the
value consistent across the codebase which means you're going down the path of
renaming a lot more stuff like the entire PageScaleAnimation and
PageScaleConstraintsSet classes.  But those things don't even have to do with
pinch so it's not clear that's an improvement.

Ultimately I think readers of this code do need a basic understanding of the
difference between page scale and full-page zoom.  If they don't, they'll still
be confused regardless of what we name things.  And once they do, the code is
unambiguous because we consistently use "scale" for the first one and "zoom" for
the other.  So I don't think this is urgent or obviously an improvement given
the other concern about not everything being pinch.

Moreover I think you should focus on shipping the behavior change and spend your
time on a big mechanical rename right now.  This would be easier when Blink is
merged with Chromium, anyway.

+
+    // Gets the scale factor set on the pinch-to-zoom viewport.
+    virtual float pinchViewportScaleFactor() const = 0;
+
+    // Sets the offset of the pinch-to-zoom viewport within the main frame, in
+    // partial CSS pixels. The offset will be clamped so the pinch viewport
+    // stays within the frame's bounds.
+    virtual void setPinchViewportOffset(const WebFloatPoint&) = 0;
+
+    // Gets the pinch viewport's current offset within the page's main frame,
+    // in partial CSS pixels.
+    virtual WebFloatPoint pinchViewportOffset() const = 0;
+
     // PageScaleFactor will be force-clamped between minPageScale and maxPageScale
     // (and these values will persist until setPageScaleFactorLimits is called
     // again).
     virtual void setPageScaleFactorLimits(float minPageScale, float maxPageScale) = 0;

[aelias_OOO_until_Jul13, 2014/04/09 21:22:52]

Here are three more "PageScaleFactor" methods if you want to rename things.

 
     virtual float minimumPageScaleFactor() const = 0;
     virtual float maximumPageScaleFactor() const = 0;
 
     // Save the WebView's current scroll and scale state. Each call to this function
     // overwrites the previously saved scroll and scale state.
     virtual void saveScrollAndScaleState() = 0;
 
     // Restore the previously saved scroll and scale state. After restoring the
     // state, this function deletes any saved scroll and scale state.
@@ skipping 232 matching lines @@
 
     // Testing functionality for TestRunner ---------------------------------
 
 protected:
     ~WebView() {}
 };
 
 } // namespace blink
 
 #endif