Move MaxScrollOffset to property_trees

cc/trees/layer_tree_impl.cc

Index: cc/trees/layer_tree_impl.cc
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 46561da920d67ada5df4ccbb8314cf19304699e9..80cddc1f7a29b8f2d75eccc51f897e81f8dd0890 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -300,11 +300,12 @@ void LayerTreeImpl::UpdatePropertyTreesForBoundsDelta() {
   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());
 }
 
 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
@@ -312,6 +313,7 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
   target_tree->SetPropertyTrees(property_trees_);
+  target_tree->property_trees()->SetupInternalPointers();
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
@@ -484,13 +486,27 @@ void LayerTreeImpl::UpdatePropertyTreeScrollingAndAnimationFromMainThread() {
       });
 }
 
-void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale) {
+void LayerTreeImpl::SetPageScaleOnActiveTreeForTesting(

[ajuma, 2016/02/09 16:27:13]

Can callers of this just call SetPageScaleOnActiveTree instead (so we don't need
this testing-only method)?

+    float active_page_scale) {
   DCHECK(IsActiveTree());
   if (page_scale_factor()->SetCurrent(
           ClampPageScaleFactorToLimits(active_page_scale)))
     DidUpdatePageScale();
 }
 
+void LayerTreeImpl::SetPageScaleOnActiveTree(float active_page_scale) {
+  DCHECK(IsActiveTree());
+  if (page_scale_factor()->SetCurrent(
+          ClampPageScaleFactorToLimits(active_page_scale))) {
+    gfx::Transform identity_transform;
+    UpdatePageScaleFactorInPropertyTrees(
+        property_trees(), PageScaleLayer(),
+        ClampPageScaleFactorToLimits(active_page_scale), device_scale_factor(),
+        identity_transform);
+    DidUpdatePageScale();
+  }
+}
+
 void LayerTreeImpl::PushPageScaleFromMainThread(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
@@ -503,6 +519,10 @@ void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* 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;
@@ -511,7 +531,33 @@ void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* page_scale_factor,
     // compositor thread after the begin frame, which is the delta check above.
     changed_page_scale |=
         page_scale_factor_->PushFromMainThread(*page_scale_factor);
+    if (PageScaleLayer()) {
+      gfx::Transform identity_transform;
+      UpdatePageScaleFactorInPropertyTrees(
+          property_trees(), PageScaleLayer(),
+          ClampPageScaleFactorToLimits(*page_scale_factor),
+          device_scale_factor(), identity_transform);
+    } else {
+      property_trees()->transform_tree.set_page_scale_factor(
+          ClampPageScaleFactorToLimits(*page_scale_factor));
+    }
+  } else {
+    // Active tree already knows the page_scale_factor, needs to update the
+    // factor in transform tree.

[ajuma, 2016/02/09 16:27:13]

I'm not sure I follow this comment. We could be pushing to the pending tree
here.

+    if (PageScaleLayer()) {
+      gfx::Transform identity_transform;
+      UpdatePageScaleFactorInPropertyTrees(
+          property_trees(), PageScaleLayer(),
+          ClampPageScaleFactorToLimits(
+              page_scale_factor_->Current(IsActiveTree())),
+          device_scale_factor(), identity_transform);
+    } else {
+      property_trees()->transform_tree.set_page_scale_factor(
+          ClampPageScaleFactorToLimits(
+              page_scale_factor_->Current(IsActiveTree())));
+    }

[ajuma, 2016/02/09 16:27:13]

What goes wrong if we wait till UpdateDrawProperties time for the property trees
to find out about the page scale factor? (Since page scale factor is a
SyncedProperty, changes on the active tree immediately affect the value seen by
the pending tree, even though nothing gets called on the pending tree, so
pulling the value at UpdateDrawProperties time seems to be the least complex way
to make sure we use the correct value when computing draw properties. If there
are callers that need property trees to have an up-to-date page scale even
before we updated draw properties, it might be better for those callers to
ensure this.)

   }
+
   if (IsActiveTree()) {
     // TODO(enne): Pushing from pending to active should never require
     // DidUpdatePageScale.  The values should already be set by the fully
@@ -520,9 +566,6 @@ void LayerTreeImpl::PushPageScaleFactorAndLimits(const float* page_scale_factor,
     changed_page_scale |= page_scale_factor_->PushPendingToActive();
   }
 
-  changed_page_scale |=
-      SetPageScaleFactorLimits(min_page_scale_factor, max_page_scale_factor);
-
   if (changed_page_scale)
     DidUpdatePageScale();
 }