Move page scale ownership to LayerTreeImpl.

cc/layer_tree_impl.cc

 // Copyright 2011 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/layer_tree_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(LayerTreeHostImpl* layer_tree_host_impl)
     : layer_tree_host_impl_(layer_tree_host_impl)
     , source_frame_number_(-1)
     , hud_layer_(0)
     , root_scroll_layer_(0)
     , currently_scrolling_layer_(0)
     , background_color_(0)
     , has_transparent_background_(false)
+    , page_scale_factor_(1)
+    , page_scale_delta_(1)
+    , sent_page_scale_delta_(1)
+    , min_page_scale_factor_(0)
+    , max_page_scale_factor_(0)
     , scrolling_layer_id_from_previous_tree_(0)
     , contents_textures_purged_(false)
     , needs_update_draw_properties_(true) {
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
   // Need to explicitly clear the tree prior to destroying this so that
   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
   root_layer_.reset();
 }
@@ skipping 55 matching lines @@
 LayerImpl* LayerTreeImpl::CurrentlyScrollingLayer() {
   DCHECK(IsActiveTree());
   return currently_scrolling_layer_;
 }
 
 void LayerTreeImpl::ClearCurrentlyScrollingLayer() {
   currently_scrolling_layer_ = NULL;
   scrolling_layer_id_from_previous_tree_ = 0;
 }
 
+void LayerTreeImpl::SetPageScaleFactorAndLimits(float page_scale_factor,
+    float min_page_scale_factor, float max_page_scale_factor)
+{
+  if (!page_scale_factor)
+    return;
+
+  min_page_scale_factor_ = min_page_scale_factor;
+  max_page_scale_factor_ = max_page_scale_factor;
+  page_scale_factor_ = page_scale_factor;
+}
+
+void LayerTreeImpl::SetPageScaleDelta(float delta)
+{
+  // Clamp to the current min/max limits.
+  float total = page_scale_factor_ * delta;
+  if (min_page_scale_factor_ && total < min_page_scale_factor_)
+    delta = min_page_scale_factor_ / page_scale_factor_;
+  else if (max_page_scale_factor_ && total > max_page_scale_factor_)
+    delta = max_page_scale_factor_ / page_scale_factor_;
+
+  if (delta == page_scale_delta_)
+    return;
+
+  page_scale_delta_ = delta;
+
+  if (IsActiveTree())
+  {

[danakj, 2013/01/28 20:29:03]

nit: { on previous line

[aelias_OOO_until_Jul13, 2013/01/29 06:05:14]

Done.

+      LayerTreeImpl* pending_tree = layer_tree_host_impl_->pendingTree();

[danakj, 2013/01/28 20:29:03]

2 space indents and 80 col

[aelias_OOO_until_Jul13, 2013/01/29 06:05:14]

Done.

+      if (pending_tree) {
+          DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
+          pending_tree->SetPageScaleDelta(page_scale_delta_ / sent_page_scale_delta_);
+      }
+  }
+
+#if 0
+    if (layerTreeImpl()->IsActiveTree())
+    {
+        LayerImpl* pending_twin = layerTreeImpl()->FindPendingTreeLayerById(id());
+        if (pending_twin) {
+            // The pending twin can't mirror the scroll delta of the active
+            // layer.  Although the delta - sent scroll delta difference is
+            // identical for both twins, the sent scroll delta for the pending
+            // layer is zero, as anything that has been sent has been baked
+            // into the layer's position/scroll offset as a part of commit.
+            DCHECK(pending_twin->sentScrollDelta().IsZero());
+            pending_twin->setScrollDelta(scrollDelta - sentScrollDelta());
+        }
+    }
+#endif
+
+  UpdateMaxScrollOffset();
+  set_needs_update_draw_properties();
+}
+
 gfx::SizeF LayerTreeImpl::ScrollableViewportSize() const {
   gfx::SizeF view_bounds;
   // The clip layer should be used for scrolling bounds if available since it
   // adjusts for non-overlay scrollbars. Otherwise, fall back to our knowledge
   // of the physical viewport size.
   LayerImpl* clip_layer = NULL;
   if (root_scroll_layer_)
     clip_layer = root_scroll_layer_->parent();
   if (clip_layer && clip_layer->masksToBounds()) {
     view_bounds = clip_layer->bounds();
   } else {
     view_bounds = gfx::ScaleSize(device_viewport_size(),
         1 / device_scale_factor());
   }
-  view_bounds.Scale(1 / pinch_zoom_viewport().total_page_scale_factor());
+  view_bounds.Scale(1 / total_page_scale_factor());
 
   return view_bounds;
 }
 
 void LayerTreeImpl::UpdateMaxScrollOffset() {
   if (!root_scroll_layer_ || !root_scroll_layer_->children().size())
     return;
 
   gfx::Vector2dF max_scroll = gfx::Rect(ScrollableSize()).bottom_right() -
       gfx::RectF(ScrollableViewportSize()).bottom_right();
 
   // The viewport may be larger than the contents in some cases, such as
   // having a vertical scrollbar but no horizontal overflow.
   max_scroll.ClampToMin(gfx::Vector2dF());
 
   root_scroll_layer_->setMaxScrollOffset(gfx::ToFlooredVector2d(max_scroll));
 }
 
+gfx::Transform LayerTreeImpl::ImplTransform() const {
+  gfx::Transform transform;
+  transform.Scale(page_scale_delta_, page_scale_delta_);
+  if (settings().pageScalePinchZoomEnabled)
+      transform.Scale(page_scale_factor_, page_scale_factor_);
+  return transform;
+}
+
 struct UpdateTilePrioritiesForLayer {
   void operator()(LayerImpl *layer) {
     layer->updateTilePriorities();
   }
 };
 
 void LayerTreeImpl::UpdateDrawProperties(UpdateDrawPropertiesReason reason) {
   if (!needs_update_draw_properties_) {
     if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && RootLayer())
       LayerTreeHostCommon::callFunctionForSubtree<UpdateTilePrioritiesForLayer>(
           RootLayer());
     return;
   }
 
   needs_update_draw_properties_ = false;
   render_surface_layer_list_.clear();
 
   // For maxTextureSize.
   if (!layer_tree_host_impl_->renderer())
       return;
 
   if (!RootLayer())
     return;
 
   if (root_scroll_layer_) {
-    root_scroll_layer_->setImplTransform(
-        layer_tree_host_impl_->implTransform());
+    root_scroll_layer_->setImplTransform(ImplTransform());
     // Setting the impl transform re-sets this.
     needs_update_draw_properties_ = false;
   }
 
   {
     TRACE_EVENT1("cc", "LayerTreeImpl::UpdateDrawProperties", "IsActive", IsActiveTree());
     bool update_tile_priorities =
         reason == UPDATE_PENDING_TREE ||
         reason == UPDATE_ACTIVE_TREE_FOR_DRAW;
     LayerTreeHostCommon::calculateDrawProperties(
         RootLayer(),
         device_viewport_size(),
         device_scale_factor(),
-        pinch_zoom_viewport().total_page_scale_factor(),
+        total_page_scale_factor(),
         MaxTextureSize(),
         settings().canUseLCDText,
         render_surface_layer_list_,
         update_tile_priorities);
   }
 
   DCHECK(!needs_update_draw_properties_) <<
       "calcDrawProperties should not set_needs_update_draw_properties()";
 }
 
@@ skipping 175 matching lines @@
 }
 
 DebugRectHistory* LayerTreeImpl::debug_rect_history() const {
   return layer_tree_host_impl_->debugRectHistory();
 }
 
 AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
   return layer_tree_host_impl_->animationRegistrar();
 }
 
-const PinchZoomViewport& LayerTreeImpl::pinch_zoom_viewport() const {
-  return layer_tree_host_impl_->pinchZoomViewport();
-}
-
 } // namespace cc