Refactor pinch-zoom viewport.

Refactors the class PinchZoomViewport to (1) move it out of layer_tree_host_impl.* and (2) convert it to Chromium style.

BUG=none


Review URL: https://chromiumcodereview.appspot.com/11829006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@175996 0039d316-1c4b-4281-b951-d872f2087c98

cc/cc.gyp

@@ -154,6 +154,8 @@
       'picture_pile.h',
       'picture_pile_impl.cc',
       'picture_pile_impl.h',
+      'pinch_zoom_viewport.cc',
+      'pinch_zoom_viewport.h',
       'platform_color.h',
       'prioritized_resource.cc',
       'prioritized_resource.h',

cc/layer_tree_host_impl.h

@@ -13,6 +13,7 @@
 #include "cc/cc_export.h"
 #include "cc/input_handler.h"
 #include "cc/output_surface_client.h"
+#include "cc/pinch_zoom_viewport.h"
 #include "cc/render_pass.h"
 #include "cc/render_pass_sink.h"
 #include "cc/renderer.h"
@@ -54,65 +55,6 @@ public:
     virtual void sendManagedMemoryStats() = 0;
 };
 
-// PinchZoomViewport models the bounds and offset of the viewport that is used during a pinch-zoom operation.
-// It tracks the layout-space dimensions of the viewport before any applied scale, and then tracks the layout-space
-// coordinates of the viewport respecting the pinch settings.
-class CC_EXPORT PinchZoomViewport {
-public:
-    PinchZoomViewport();
-
-    float totalPageScaleFactor() const;
-
-    void setPageScaleFactor(float factor) { m_pageScaleFactor = factor; }
-    float pageScaleFactor() const { return m_pageScaleFactor; }
-
-    void setPageScaleDelta(float delta);
-    float pageScaleDelta() const  { return m_pageScaleDelta; }
-
-    float minPageScaleFactor() const { return m_minPageScaleFactor; }
-    float maxPageScaleFactor() const { return m_maxPageScaleFactor; }
-
-    void setSentPageScaleDelta(float delta) { m_sentPageScaleDelta = delta; }
-    float sentPageScaleDelta() const { return m_sentPageScaleDelta; }
-
-    void setDeviceScaleFactor(float factor) { m_deviceScaleFactor = factor; }
-    float deviceScaleFactor() const { return m_deviceScaleFactor; }
-
-    // Returns true if the passed parameters were different from those previously
-    // cached.
-    bool setPageScaleFactorAndLimits(float pageScaleFactor,
-                                     float minPageScaleFactor,
-                                     float maxPageScaleFactor);
-
-    // Returns the bounds and offset of the scaled and translated viewport to use for pinch-zoom.
-    gfx::RectF bounds() const;
-    const gfx::Vector2dF& zoomedViewportOffset() const { return m_zoomedViewportOffset; }
-
-    void setLayoutViewportSize(const gfx::SizeF& size) { m_layoutViewportSize = size; }
-
-    // Apply the scroll offset in layout space to the offset of the pinch-zoom viewport. The viewport cannot be
-    // scrolled outside of the layout viewport bounds. Returns the component of the scroll that is un-applied due to
-    // this constraint.
-    gfx::Vector2dF applyScroll(const gfx::Vector2dF&);
-
-    // The implTransform goes from the origin of the unzoomedDeviceViewport to the
-    // origin of the zoomedDeviceViewport.
-    //
-    // implTransform = S[pageScale] * Tr[-zoomedDeviceViewportOffset]
-    gfx::Transform implTransform(bool pageScalePinchZoomEnabled) const;
-
-private:
-    float m_pageScaleFactor;
-    float m_pageScaleDelta;
-    float m_sentPageScaleDelta;
-    float m_maxPageScaleFactor;
-    float m_minPageScaleFactor;
-    float m_deviceScaleFactor;
-
-    gfx::Vector2dF m_zoomedViewportOffset;
-    gfx::SizeF m_layoutViewportSize;
-};
-
 // LayerTreeHostImpl owns the LayerImpl tree as well as associated rendering state
 class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
                                     public RendererClient,
@@ -298,7 +240,7 @@ public:
     template<typename RenderPassCuller>
     static void removeRenderPasses(RenderPassCuller, FrameData&);
 
-    float totalPageScaleFactorForTesting() const { return m_pinchZoomViewport.totalPageScaleFactor(); }
+    float totalPageScaleFactorForTesting() const { return m_pinchZoomViewport.total_page_scale_factor(); }
 
     const PinchZoomViewport& pinchZoomViewport() const { return m_pinchZoomViewport; }
 

cc/layer_tree_impl.cc

@@ -93,11 +93,11 @@ void LayerTreeImpl::UpdateMaxScrollOffset() {
     // Pinch with pageScale scrolls entirely in layout space.  ContentSize
     // returns the bounds including the page scale factor, so calculate the
     // pre page-scale layout size here.
-    float page_scale_factor = pinch_zoom_viewport().pageScaleFactor();
+    float page_scale_factor = pinch_zoom_viewport().page_scale_factor();
     content_bounds.set_width(content_bounds.width() / page_scale_factor);
     content_bounds.set_height(content_bounds.height() / page_scale_factor);
   } else {
-    view_bounds.Scale(1 / pinch_zoom_viewport().pageScaleDelta());
+    view_bounds.Scale(1 / pinch_zoom_viewport().page_scale_delta());
   }
 
   gfx::Vector2dF max_scroll = gfx::Rect(content_bounds).bottom_right() -
@@ -127,7 +127,7 @@ void LayerTreeImpl::UpdateDrawProperties() {
         RootLayer(),
         device_viewport_size(),
         device_scale_factor(),
-        pinch_zoom_viewport().pageScaleFactor(),
+        pinch_zoom_viewport().page_scale_factor(),
         MaxTextureSize(),
         settings().canUseLCDText,
         render_surface_layer_list_);

cc/pinch_zoom_viewport.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/pinch_zoom_viewport.h"
+
+#include "base/logging.h"
+
+namespace cc {
+
+PinchZoomViewport::PinchZoomViewport()
+    : page_scale_factor_(1),
+      page_scale_delta_(1),
+      sent_page_scale_delta_(1),
+      min_page_scale_factor_(0),
+      max_page_scale_factor_(0),
+      device_scale_factor_(1) {
+}
+
+void PinchZoomViewport::set_page_scale_delta(float delta) {
+  // Clamp to the current min/max limits.
+  float totalPageScaleFactor = page_scale_factor_ * delta;
+  if (min_page_scale_factor_ && totalPageScaleFactor < min_page_scale_factor_)
+    delta = min_page_scale_factor_ / page_scale_factor_;
+  else if (max_page_scale_factor_ &&
+           totalPageScaleFactor > max_page_scale_factor_)
+    delta = max_page_scale_factor_ / page_scale_factor_;
+
+  if (delta == page_scale_delta_)
+    return;
+
+  page_scale_delta_ = delta;
+}
+
+bool PinchZoomViewport::SetPageScaleFactorAndLimits(
+    float page_scale_factor,
+    float min_page_scale_factor,
+    float max_page_scale_factor) {
+  DCHECK(page_scale_factor);
+
+  if (sent_page_scale_delta_ == 1 && page_scale_factor == page_scale_factor_ &&
+      min_page_scale_factor == min_page_scale_factor_ &&
+      max_page_scale_factor == max_page_scale_factor_)
+    return false;
+
+  min_page_scale_factor_ = min_page_scale_factor;
+  max_page_scale_factor_ = max_page_scale_factor;
+
+  page_scale_factor_ = page_scale_factor;
+  return true;
+}
+
+gfx::RectF PinchZoomViewport::Bounds() const {
+  gfx::RectF bounds(gfx::PointF(), layout_viewport_size_);
+  bounds.Scale(1 / total_page_scale_factor());
+  bounds += zoomed_viewport_offset_;
+  return bounds;
+}
+
+gfx::Vector2dF PinchZoomViewport::ApplyScroll(const gfx::Vector2dF delta) {
+  gfx::Vector2dF overflow;
+  gfx::RectF pinched_bounds = Bounds() + delta;
+
+  if (pinched_bounds.x() < 0) {
+    overflow.set_x(pinched_bounds.x());
+    pinched_bounds.set_x(0);
+  }
+
+  if (pinched_bounds.y() < 0) {
+    overflow.set_y(pinched_bounds.y());
+    pinched_bounds.set_y(0);
+  }
+
+  if (pinched_bounds.right() > layout_viewport_size_.width()) {
+    overflow.set_x(pinched_bounds.right() - layout_viewport_size_.width());
+    pinched_bounds += gfx::Vector2dF(
+      layout_viewport_size_.width() - pinched_bounds.right(), 0);
+  }
+
+  if (pinched_bounds.bottom() > layout_viewport_size_.height()) {
+    overflow.set_y(pinched_bounds.bottom() - layout_viewport_size_.height());
+    pinched_bounds += gfx::Vector2dF(
+      0, layout_viewport_size_.height() - pinched_bounds.bottom());
+  }
+  zoomed_viewport_offset_ = pinched_bounds.OffsetFromOrigin();
+
+  return overflow;
+}
+
+gfx::Transform PinchZoomViewport::ImplTransform(
+    bool page_scale_pinch_zoom_enabled) const {
+  gfx::Transform transform;
+  transform.Scale(page_scale_delta_, page_scale_delta_);
+
+  // If the pinch state is applied in the impl, then push it to the
+  // impl transform, otherwise the scale is handled by WebCore.
+  if (page_scale_pinch_zoom_enabled) {
+    transform.Scale(page_scale_factor_, page_scale_factor_);
+    // The offset needs to be scaled by deviceScaleFactor as this transform
+    // needs to work with physical pixels.
+    gfx::Vector2dF zoomed_device_viewport_offset
+      = gfx::ScaleVector2d(zoomed_viewport_offset_, device_scale_factor_);
+    transform.Translate(-zoomed_device_viewport_offset.x(),
+                        -zoomed_device_viewport_offset.y());
+  }
+
+  return transform;
+}
+
+}  // namespace cc

cc/pinch_zoom_viewport.h

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_PINCH_ZOOM_VIEWPORT_H_
+#define CC_PINCH_ZOOM_VIEWPORT_H_
+
+#include "cc/cc_export.h"
+#include "ui/gfx/rect.h"
+#include "ui/gfx/transform.h"
+
+namespace cc {
+
+// PinchZoomViewport models the bounds and offset of the viewport that is used
+// during a pinch-zoom operation. It tracks the layout-space dimensions of the
+// viewport before any applied scale, and then tracks the layout-space
+// coordinates of the viewport respecting the pinch settings.
+class CC_EXPORT PinchZoomViewport {
+ public:
+  PinchZoomViewport();
+
+  float total_page_scale_factor() const {
+    return page_scale_factor_ * page_scale_delta_;
+  }
+
+  void set_page_scale_factor(float factor) { page_scale_factor_ = factor; }
+  float page_scale_factor() const { return page_scale_factor_; }
+
+  void set_page_scale_delta(float delta);
+  float page_scale_delta() const  { return page_scale_delta_; }
+
+  float min_page_scale_factor() const { return min_page_scale_factor_; }
+  float max_page_scale_factor() const { return max_page_scale_factor_; }
+
+  void set_sent_page_scale_delta(float delta) {
+    sent_page_scale_delta_ = delta;
+  }
+
+  float sent_page_scale_delta() const { return sent_page_scale_delta_; }
+
+  void set_device_scale_factor(float factor) { device_scale_factor_ = factor; }
+  float device_scale_factor() const { return device_scale_factor_; }
+
+  // Returns true if the passed parameters were different from those previously
+  // cached.
+  bool SetPageScaleFactorAndLimits(float page_scale_factor,
+                                   float min_page_scale_factor,
+                                   float max_page_scale_factor);
+
+  // Returns the bounds and offset of the scaled and translated viewport to use
+  // for pinch-zoom.
+  gfx::RectF Bounds() const;
+
+  const gfx::Vector2dF& zoomed_viewport_offset() const {
+    return zoomed_viewport_offset_;
+  }
+
+  void set_layout_viewport_size(const gfx::SizeF& size) {
+    layout_viewport_size_ = size;
+  }
+
+  // Apply the scroll offset in layout space to the offset of the pinch-zoom
+  // viewport. The viewport cannot be scrolled outside of the layout viewport
+  // bounds. Returns the component of the scroll that is un-applied due to this
+  // constraint.
+  gfx::Vector2dF ApplyScroll(const gfx::Vector2dF);
+
+  // The implTransform goes from the origin of the unzoomedDeviceViewport to the
+  // origin of the zoomedDeviceViewport.
+  //
+  // implTransform = S[pageScale] * Tr[-zoomedDeviceViewportOffset]
+  gfx::Transform ImplTransform(bool page_scale_pinch_zoom_enabled) const;
+
+ private:
+  float page_scale_factor_;
+  float page_scale_delta_;
+  float sent_page_scale_delta_;
+  float max_page_scale_factor_;
+  float min_page_scale_factor_;
+  float device_scale_factor_;
+
+  gfx::Vector2dF zoomed_viewport_offset_;
+  gfx::SizeF layout_viewport_size_;
+};
+
+}  // namespace cc
+
+#endif  // CC_PINCH_ZOOM_VIEWPORT_H_