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 282 matching lines @@
   LayerImpl* inner_container = InnerViewportContainerLayer();
   LayerImpl* outer_container = OuterViewportContainerLayer();
 
   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());
 }
 
 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_);
+  target_tree->property_trees()->SetupInternalPointers();
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
     next_activation_forces_redraw_ = false;
   }
 
   target_tree->PassSwapPromises(&swap_promise_list_);
 
   target_tree->set_top_controls_shrink_blink_size(
       top_controls_shrink_blink_size_);
@@ skipping 152 matching lines @@
   // after begin frame and updates from animations that have ticked since begin
   // frame to a newly-committed property tree.
   if (!root_layer())
     return;
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer(), [](LayerImpl* layer) {
         layer->UpdatePropertyTreeForScrollingAndAnimationIfNeeded();
       });
 }
 
-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) {
   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 (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
     // 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();
 }
 
 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())
@@ skipping 1514 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