Move MaxScrollOffset to property_trees

cc/trees/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/trees/layer_tree_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 274 matching lines @@
         clip_tree->set_needs_update(true);
       }
     }
   }
 }
 
 void LayerTreeImpl::UpdatePropertyTreesForBoundsDelta() {
   DCHECK(IsActiveTree());
   LayerImpl* inner_container = InnerViewportContainerLayer();
   LayerImpl* outer_container = OuterViewportContainerLayer();
+  LayerImpl* inner_scroll = InnerViewportScrollLayer();
 
   UpdateClipTreeForBoundsDeltaOnLayer(inner_container,
                                       &property_trees_.clip_tree);
   UpdateClipTreeForBoundsDeltaOnLayer(InnerViewportScrollLayer(),
                                       &property_trees_.clip_tree);
   UpdateClipTreeForBoundsDeltaOnLayer(outer_container,
                                       &property_trees_.clip_tree);
 
-  TransformTree& transform_tree = property_trees_.transform_tree;
   if (inner_container)
-    transform_tree.SetInnerViewportBoundsDelta(inner_container->bounds_delta());
+    property_trees_.SetInnerViewportContainerBoundsDelta(
+        inner_container->bounds_delta());
   if (outer_container)
-    transform_tree.SetOuterViewportBoundsDelta(outer_container->bounds_delta());
+    property_trees_.SetOuterViewportContainerBoundsDelta(
+        outer_container->bounds_delta());
+  if (inner_scroll)
+    property_trees_.SetInnerViewportScrollBoundsDelta(
+        inner_scroll->bounds_delta());
 }
 
 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
   target_tree->SetPropertyTrees(property_trees_);
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
@@ skipping 162 matching lines @@
     return;
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer(), [](LayerImpl* layer) {
         layer->UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
       });
 }
 
 void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale) {
   DCHECK(IsActiveTree());
   if (page_scale_factor()->SetCurrent(
-          ClampPageScaleFactorToLimits(active_page_scale)))
+          ClampPageScaleFactorToLimits(active_page_scale))) {
     DidUpdatePageScale();
+    if (PageScaleLayer()) {
+      UpdatePageScaleFactorInPropertyTrees(
+          property_trees(), PageScaleLayer(), current_page_scale_factor(),
+          device_scale_factor(), layer_tree_host_impl_->DrawTransform());
+    } else {
+      DCHECK(!root_layer_ || active_page_scale == 1);
+    }
+  }
 }
 
 void LayerTreeImpl::PushPageScaleFromMainThread(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
   PushPageScaleFactorAndLimits(&page_scale_factor, min_page_scale_factor,
                                max_page_scale_factor);
 }
 
 void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* page_scale_factor,
                                                  float min_page_scale_factor,
                                                  float max_page_scale_factor) {
   DCHECK(page_scale_factor || IsActiveTree());
   bool changed_page_scale = false;
+
+  changed_page_scale |=
+      SetPageScaleFactorLimits(min_page_scale_factor, max_page_scale_factor);
+
   if (page_scale_factor) {
     DCHECK(!IsActiveTree() || !layer_tree_host_impl_->pending_tree());
     changed_page_scale |= page_scale_factor_->Delta() != 1.f;
     // TODO(enne): Once CDP goes away, ignore this call below.  The only time
     // the property trees will differ is if there's been a page scale on the
     // compositor thread after the begin frame, which is the delta check above.
     changed_page_scale |=
         page_scale_factor_->PushFromMainThread(*page_scale_factor);
   }
+
   if (IsActiveTree()) {
     // TODO(enne): Pushing from pending to active should never require
     // DidUpdatePageScale.  The values should already be set by the fully
     // computed property trees being synced from one tree to another.  Remove
     // this once CDP goes away.
     changed_page_scale |= page_scale_factor_->PushPendingToActive();
   }
 
-  changed_page_scale |=
-      SetPageScaleFactorLimits(min_page_scale_factor, max_page_scale_factor);
-
   if (changed_page_scale)
     DidUpdatePageScale();
+
+  if (page_scale_factor) {  // && !property_trees()->needs_rebuild) {

[ajuma, 2016/02/10 22:30:19]

The commented-out code needs to be removed.

+    if (PageScaleLayer()) {
+      UpdatePageScaleFactorInPropertyTrees(
+          property_trees(), PageScaleLayer(), current_page_scale_factor(),
+          device_scale_factor(), layer_tree_host_impl_->DrawTransform());
+    } else {
+      DCHECK(!root_layer_ || *page_scale_factor == 1);
+    }
+  }
 }
 
 void LayerTreeImpl::set_top_controls_shrink_blink_size(bool shrink) {
   if (top_controls_shrink_blink_size_ == shrink)
     return;
 
   top_controls_shrink_blink_size_ = shrink;
   if (IsActiveTree())
     layer_tree_host_impl_->UpdateViewportContainerSizes();
 }
@@ skipping 1512 matching lines @@
                                                    const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   *bounds = gfx::BoxF();
   return layer_tree_host_impl_->animation_host()
              ? layer_tree_host_impl_->animation_host()
                    ->TransformAnimationBoundsForBox(layer->id(), box, bounds)
              : true;
 }
 
 }  // namespace cc