Reuse property trees

This patch adds a needs_rebuild boolean to PropertyTrees
and resets it each time the trees are rebuilt. Certain
layer operations do not require a rebuild and can instead
mutate an existing property tree node (e.g., updating a
scroll offset). Special care is taken in Layer to avoid
setting needs_rebuild in these cases.

BUG=470272

Review URL: https://codereview.chromium.org/1088773003

Cr-Commit-Position: refs/heads/master@{#325694}

cc/layers/layer.cc

@@ -118,6 +118,9 @@ void Layer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host_ == host)
     return;
 
+  if (layer_tree_host_)
+    layer_tree_host_->property_trees()->needs_rebuild = true;
+
   layer_tree_host_ = host;
 
   // When changing hosts, the layer needs to commit its properties to the impl
@@ -153,6 +156,19 @@ void Layer::SetNeedsCommit() {
   if (!layer_tree_host_)
     return;
 
+  SetNeedsPushProperties();
+  layer_tree_host_->property_trees()->needs_rebuild = true;
+
+  if (ignore_set_needs_commit_)
+    return;
+
+  layer_tree_host_->SetNeedsCommit();
+}
+
+void Layer::SetNeedsCommitNoRebuild() {
+  if (!layer_tree_host_)
+    return;
+
   SetNeedsPushProperties();
 
   if (ignore_set_needs_commit_)
@@ -335,9 +351,19 @@ void Layer::SetBounds(const gfx::Size& size) {
   DCHECK(IsPropertyChangeAllowed());
   if (bounds() == size)
     return;
-
   bounds_ = size;
-  SetNeedsCommit();
+
+  if (!layer_tree_host_)
+    return;
+
+  if (ClipNode* clip_node = layer_tree_host_->property_trees()->clip_tree.Node(
+          clip_tree_index())) {
+    if (clip_node->owner_id == id()) {
+      clip_node->data.clip.set_size(size);
+    }
+  }
+
+  SetNeedsCommitNoRebuild();
 }
 
 Layer* Layer::RootLayer() {
@@ -577,6 +603,22 @@ void Layer::SetPosition(const gfx::PointF& position) {
   if (position_ == position)
     return;
   position_ = position;
+
+  if (!layer_tree_host_)
+    return;
+
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.update_post_local_transform(position,
+                                                       transform_origin());
+      transform_node->data.needs_local_transform_update = true;
+      SetNeedsCommitNoRebuild();
+      return;
+    }
+  }
+
   SetNeedsCommit();
 }
 
@@ -588,12 +630,53 @@ bool Layer::IsContainerForFixedPositionLayers() const {
   return is_container_for_fixed_position_layers_;
 }
 
+bool Are2dAxisAligned(const gfx::Transform& a,
+                      const gfx::Transform& b,
+                      bool* is_invertible) {
+  if (a.IsScaleOrTranslation() && b.IsScaleOrTranslation()) {
+    *is_invertible = b.IsInvertible();
+    return true;
+  }
+
+  gfx::Transform inverse(gfx::Transform::kSkipInitialization);
+  *is_invertible = b.GetInverse(&inverse);
+
+  inverse *= a;
+  return inverse.Preserves2dAxisAlignment();
+}
+
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
+
+  if (layer_tree_host_) {
+    if (TransformNode* transform_node =
+            layer_tree_host_->property_trees()->transform_tree.Node(
+                transform_tree_index())) {
+      if (transform_node->owner_id == id()) {
+        // We need to trigger a rebuild if we could have affected 2d axis
+        // alignment. We'll check to see if transform and transform_ are axis
+        // align with respect to one another.
+        bool invertible = false;
+        bool preserves_2d_axis_alignment =
+            Are2dAxisAligned(transform_, transform, &invertible);
+        transform_node->data.local = transform;
+        transform_node->data.needs_local_transform_update = true;
+        if (preserves_2d_axis_alignment)
+          SetNeedsCommitNoRebuild();
+        else
+          SetNeedsCommit();
+        transform_ = transform;
+        transform_is_invertible_ = invertible;
+        return;
+      }
+    }
+  }
+
   transform_ = transform;
   transform_is_invertible_ = transform.IsInvertible();
+
   SetNeedsCommit();
 }
 
@@ -602,6 +685,22 @@ void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   if (transform_origin_ == transform_origin)
     return;
   transform_origin_ = transform_origin;
+
+  if (!layer_tree_host_)
+    return;
+
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.update_post_local_transform(position(),
+                                                       transform_origin);
+      transform_node->data.needs_local_transform_update = true;
+      SetNeedsCommitNoRebuild();
+      return;
+    }
+  }
+
   SetNeedsCommit();
 }
 
@@ -679,6 +778,22 @@ void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
+
+  if (!layer_tree_host_)
+    return;
+
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.scroll_offset =
+          gfx::ScrollOffsetToVector2dF(CurrentScrollOffset());
+      transform_node->data.needs_local_transform_update = true;
+      SetNeedsCommitNoRebuild();
+      return;
+    }
+  }
+
   SetNeedsCommit();
 }
 
@@ -704,6 +819,22 @@ void Layer::SetScrollOffsetFromImplSide(
     return;
   scroll_offset_ = scroll_offset;
   SetNeedsPushProperties();
+
+  bool needs_rebuild = true;
+  if (TransformNode* transform_node =
+          layer_tree_host_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    if (transform_node->owner_id == id()) {
+      transform_node->data.scroll_offset =
+          gfx::ScrollOffsetToVector2dF(CurrentScrollOffset());
+      transform_node->data.needs_local_transform_update = true;
+      needs_rebuild = false;
+    }
+  }
+
+  if (needs_rebuild)
+    layer_tree_host_->property_trees()->needs_rebuild = true;
+
   if (!did_scroll_callback_.is_null())
     did_scroll_callback_.Run();
   // The callback could potentially change the layer structure:
@@ -1019,6 +1150,8 @@ void Layer::PushPropertiesTo(LayerImpl* layer) {
                        base::Passed(&original_request)));
     main_thread_copy_requests.push_back(main_thread_request.Pass());
   }
+  if (!copy_requests_.empty() && layer_tree_host_)
+    layer_tree_host_->property_trees()->needs_rebuild = true;
   copy_requests_.clear();
   layer->PassCopyRequests(&main_thread_copy_requests);
 
@@ -1157,13 +1290,32 @@ void Layer::OnFilterAnimated(const FilterOperations& filters) {
 
 void Layer::OnOpacityAnimated(float opacity) {
   opacity_ = opacity;
+  if (layer_tree_host_) {
+    if (OpacityNode* node =
+            layer_tree_host_->property_trees()->opacity_tree.Node(
+                opacity_tree_index_)) {
+      if (node->owner_id == id())
+        node->data = opacity;
+    }
+  }
 }
 
 void Layer::OnTransformAnimated(const gfx::Transform& transform) {
   if (transform_ == transform)
     return;
   transform_ = transform;
   transform_is_invertible_ = transform.IsInvertible();
+  if (layer_tree_host_) {
+    if (TransformNode* node =
+            layer_tree_host_->property_trees()->transform_tree.Node(
+                transform_tree_index_)) {
+      if (node->owner_id == id()) {
+        node->data.local = transform;
+        node->data.needs_local_transform_update = true;
+        node->data.is_animated = true;
+      }
+    }
+  }
 }
 
 void Layer::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {

cc/layers/layer.h

@@ -55,7 +55,6 @@ class Animation;
 class AnimationDelegate;
 struct AnimationEvent;
 class CopyOutputRequest;
-class LayerAnimationDelegate;
 class LayerAnimationEventObserver;
 class LayerClient;
 class LayerImpl;
@@ -547,6 +546,9 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
   // knows immediately that a commit is required.  This implies SetNeedsUpdate
   // as well as SetNeedsPushProperties to push that property.
   void SetNeedsCommit();
+  // This is identical to SetNeedsCommit, but the former requests a rebuild of
+  // the property trees.
+  void SetNeedsCommitNoRebuild();
   // Called when there's been a change in layer structure.  Implies both
   // SetNeedsUpdate and SetNeedsCommit, but not SetNeedsPushProperties.
   void SetNeedsFullTreeSync();

cc/trees/layer_tree_host.cc

@@ -511,6 +511,8 @@ void LayerTreeHost::SetNeedsCommit() {
 
 void LayerTreeHost::SetNeedsFullTreeSync() {
   needs_full_tree_sync_ = true;
+
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
@@ -628,6 +630,7 @@ void LayerTreeHost::SetViewportSize(const gfx::Size& device_viewport_size) {
 
   device_viewport_size_ = device_viewport_size;
 
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
@@ -651,7 +654,10 @@ void LayerTreeHost::SetTopControlsShownRatio(float ratio) {
 
 void LayerTreeHost::ApplyPageScaleDeltaFromImplSide(float page_scale_delta) {
   DCHECK(CommitRequested());
+  if (page_scale_delta == 1.f)
+    return;
   page_scale_factor_ *= page_scale_delta;
+  property_trees_.needs_rebuild = true;
 }
 
 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
@@ -665,6 +671,7 @@ void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
   page_scale_factor_ = page_scale_factor;
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
@@ -798,7 +805,6 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
     // that we won't be able to detect if a layer is part of |update_list|.
     // Change this if this information is required.
     int render_surface_layer_list_id = 0;
-    PropertyTrees property_trees;
     LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
         root_layer, device_viewport_size(), gfx::Transform(),
         device_scale_factor_, page_scale_factor_, page_scale_layer,
@@ -808,7 +814,7 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
         can_render_to_separate_surface,
         settings_.layer_transforms_should_scale_layer_contents,
         settings_.verify_property_trees, &update_list,
-        render_surface_layer_list_id, &property_trees);
+        render_surface_layer_list_id, &property_trees_);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
@@ -1121,6 +1127,7 @@ void LayerTreeHost::SetDeviceScaleFactor(float device_scale_factor) {
     return;
   device_scale_factor_ = device_scale_factor;
 
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
@@ -1141,8 +1148,12 @@ void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
-  if (animation_registrar_->AnimateLayers(monotonic_time))
-    animation_registrar_->UpdateAnimationState(true, NULL);
+  AnimationEventsVector events;
+  if (animation_registrar_->AnimateLayers(monotonic_time)) {
+    animation_registrar_->UpdateAnimationState(true, &events);
+    if (!events.empty())
+      property_trees_.needs_rebuild = true;
+  }
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {

cc/trees/layer_tree_host.h

@@ -56,6 +56,7 @@ class LayerTreeHostImplClient;
 class LayerTreeHostSingleThreadClient;
 class PrioritizedResource;
 class PrioritizedResourceManager;
+class PropertyTrees;
 class Region;
 class RenderingStatsInstrumentation;
 class ResourceProvider;
@@ -308,6 +309,8 @@ class CC_EXPORT LayerTreeHost {
 
   void SetAuthoritativeVSyncInterval(const base::TimeDelta& interval);
 
+  PropertyTrees* property_trees() { return &property_trees_; }
+
  protected:
   LayerTreeHost(LayerTreeHostClient* client,
                 SharedBitmapManager* shared_bitmap_manager,
@@ -451,6 +454,8 @@ class CC_EXPORT LayerTreeHost {
   ScopedPtrVector<SwapPromise> swap_promise_list_;
   std::set<SwapPromiseMonitor*> swap_promise_monitor_;
 
+  PropertyTrees property_trees_;
+
   uint32_t surface_id_namespace_;
   uint32_t next_surface_sequence_;
 

cc/trees/layer_tree_host_common.cc

@@ -2555,7 +2555,10 @@ void LayerTreeHostCommon::CalculateDrawProperties(
           current_layer->draw_opacity() ==
           current_layer->DrawOpacityFromPropertyTrees(
               inputs->property_trees->opacity_tree);
-      CHECK(draw_opacities_match);
+      CHECK(draw_opacities_match)
+          << "expected: " << current_layer->draw_opacity() << " actual: "
+          << current_layer->DrawOpacityFromPropertyTrees(
+                 inputs->property_trees->opacity_tree);
     }
   }
 
@@ -2592,4 +2595,14 @@ void LayerTreeHostCommon::CalculateDrawProperties(
   DCHECK(inputs->root_layer->render_surface());
 }
 
+PropertyTrees* GetPropertyTrees(Layer* layer,
+                                PropertyTrees* trees_from_inputs) {
+  return layer->layer_tree_host()->property_trees();
+}
+
+PropertyTrees* GetPropertyTrees(LayerImpl* layer,
+                                PropertyTrees* trees_from_inputs) {
+  return trees_from_inputs;
+}
+
 }  // namespace cc