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/heads_up_display_layer_impl.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 40 matching lines @@
   scrolling_layer_id_from_previous_tree_ =
     currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
   root_scroll_layer_ = NULL;
   currently_scrolling_layer_ = NULL;
 
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
   return root_layer_.Pass();
 }
 
+void LayerTreeImpl::pushPropertiesTo(LayerTreeImpl* target_tree) {
+  target_tree->SetPageScaleFactorAndLimits(
+      page_scale_factor(), min_page_scale_factor(), max_page_scale_factor());
+  target_tree->SetPageScaleDelta(
+      target_tree->page_scale_delta() / target_tree->sent_page_scale_delta());
+  target_tree->set_sent_page_scale_delta(1);
+
+  // This should match the property synchronization in
+  // LayerTreeHost::finishCommitOnImplThread().
+  target_tree->set_source_frame_number(source_frame_number());
+  target_tree->set_background_color(background_color());
+  target_tree->set_has_transparent_background(has_transparent_background());
+
+  if (ContentsTexturesPurged())
+    target_tree->SetContentsTexturesPurged();
+  else
+    target_tree->ResetContentsTexturesPurged();
+
+  if (hud_layer())
+    target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
+        LayerTreeHostCommon::findLayerInSubtree(
+            target_tree->RootLayer(), hud_layer()->id())));
+  else
+    target_tree->set_hud_layer(NULL);
+}
+
 LayerImpl* LayerTreeImpl::RootScrollLayer() {
   DCHECK(IsActiveTree());
   return root_scroll_layer_;
 }
 
 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()) {
+    LayerTreeImpl* pending_tree = layer_tree_host_impl_->pendingTree();
+    if (pending_tree) {
+      DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
+      pending_tree->SetPageScaleDelta(page_scale_delta_ / sent_page_scale_delta_);
+    }
+  }
+
+  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 179 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