Reuse property trees

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/location.h"
@@ skipping 100 matching lines @@
   if (replica_layer_.get()) {
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
   }
 }
 
 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
   // side for the new host.
   SetNeedsPushProperties();
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SetLayerTreeHost(host);
 
   if (mask_layer_.get())
@@ skipping 16 matching lines @@
 void Layer::SetNeedsUpdate() {
   if (layer_tree_host_ && !ignore_set_needs_commit_)
     layer_tree_host_->SetNeedsUpdateLayers();
 }
 
 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_)
     return;
 
   layer_tree_host_->SetNeedsCommit();
 }
 
 void Layer::SetNeedsFullTreeSync() {
   if (!layer_tree_host_)
     return;
 
+  layer_tree_host_->property_trees()->needs_rebuild = true;

[ajuma, 2015/04/16 14:52:14]

LayerTreeHost::SetNeedsFullTreeSync will trigger a rebuild, so this line
shouldn't be needed.

[enne (OOO), 2015/04/16 21:49:33]

That's kind of subtle to skip it.  I think I'd prefer to have it here.

   layer_tree_host_->SetNeedsFullTreeSync();
 }
 
 void Layer::SetNextCommitWaitsForActivation() {
   if (!layer_tree_host_)
     return;
 
   layer_tree_host_->SetNextCommitWaitsForActivation();
 }
 
@@ skipping 150 matching lines @@
     if (children_[i].get() == reference)
       return i;
   }
   return -1;
 }
 
 void Layer::SetBounds(const gfx::Size& size) {
   DCHECK(IsPropertyChangeAllowed());
   if (bounds() == size)
     return;
+  bounds_ = size;
 
-  bounds_ = size;
+  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();
+      return;
+    }
+  }
+
   SetNeedsCommit();

[ajuma, 2015/04/16 14:52:14]

In what situations will changing bounds change whether a clip node is needed?

[Ian Vollick, 2015/04/17 14:56:22]

None! I've gotten rid of the early out and we now always call
SetNeedsCommitNoRebuild().

 }
 
 Layer* Layer::RootLayer() {
   Layer* layer = this;
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
 void Layer::RemoveAllChildren() {
@@ skipping 219 matching lines @@
     return;
   contents_opaque_ = opaque;
   SetNeedsCommit();
 }
 
 void Layer::SetPosition(const gfx::PointF& position) {
   DCHECK(IsPropertyChangeAllowed());
   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();

[ajuma, 2015/04/16 14:52:13]

Can setting position change whether a transform node is needed? Or is the
rebuild needed only because offset_to_transform_parent values might change?

[Ian Vollick, 2015/04/17 14:56:22]

The latter, yeah.

 }
 
 bool Layer::IsContainerForFixedPositionLayers() const {
   if (!transform_.IsIdentityOrTranslation())
     return true;
   if (parent_ && !parent_->transform_.IsIdentityOrTranslation())
     return true;
   return is_container_for_fixed_position_layers_;
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
   transform_ = transform;
   transform_is_invertible_ = transform.IsInvertible();
+
+  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.local = transform;
+      transform_node->data.needs_local_transform_update = true;

[ajuma, 2015/04/16 14:52:14]

Could changing a transform's value affect whether this or other layers need a
clip node (by changing the result of the axis alignment check in
RequiresClipNode)? Could it change the offset_to_transform_parent for other
layers (e.g. for fixed position layers and for layer with scroll parents, where
we the offset_to_transform_parent calculation involves computing the transform
from one node to another)?

[Ian Vollick, 2015/04/17 14:56:22]

Yeah, it could. I've updated this code to check for changes to axis alignment
(and added a test).

+      SetNeedsCommitNoRebuild();
+      return;
+    }
+  }
+
   SetNeedsCommit();

[ajuma, 2015/04/16 14:52:14]

As a future optimization (not in this CL), we could probably add more checks to
avoid always re-building here (e.g. if the transform is just a 2d translation,
we don't need to rebuild).

[ajuma, 2015/04/16 14:55:04]

Actually, I take this back; a 2d translation would still mean we need to update
offset_to_transform_parent values.

[Ian Vollick, 2015/04/17 14:56:22]

We've talked about the offset_to_transform_parent stuff offline. I think we'll
still trigger rebuilds in cases where it could be affected.

 }
 
 void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   DCHECK(IsPropertyChangeAllowed());
   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();
 }
 
 bool Layer::AnimationsPreserveAxisAlignment() const {
   return layer_animation_controller_->AnimationsPreserveAxisAlignment();
 }
 
 bool Layer::TransformIsAnimating() const {
   return layer_animation_controller_->IsAnimatingProperty(Animation::TRANSFORM);
 }
@@ skipping 57 matching lines @@
     clip_children_ = nullptr;
   SetNeedsCommit();
 }
 
 void Layer::SetScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsPropertyChangeAllowed());
 
   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();
 }
 
 void Layer::SetScrollCompensationAdjustment(
     const gfx::Vector2dF& scroll_compensation_adjustment) {
   if (scroll_compensation_adjustment_ == scroll_compensation_adjustment)
     return;
   scroll_compensation_adjustment_ = scroll_compensation_adjustment;
   SetNeedsCommit();
 }
 
 gfx::Vector2dF Layer::ScrollCompensationAdjustment() const {
   return scroll_compensation_adjustment_;
 }
 
-void Layer::SetScrollOffsetFromImplSide(
-    const gfx::ScrollOffset& scroll_offset) {
+void Layer::SetScrollOffsetFromImplSide(const gfx::ScrollOffset& scroll_offset,
+                                        LayerTreeHost* host) {

[ajuma, 2015/04/16 14:52:14]

Will this ever get called with a |host| that's not layer_tree_host_?

[Ian Vollick, 2015/04/17 14:56:22]

Nope. Removed.

   DCHECK(IsPropertyChangeAllowed());
   // This function only gets called during a BeginMainFrame, so there
   // is no need to call SetNeedsUpdate here.
   DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested());
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
   SetNeedsPushProperties();
+
+  bool needs_rebuild = true;
+  if (TransformNode* transform_node =
+          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)
+    host->property_trees()->needs_rebuild = true;
+
   if (!did_scroll_callback_.is_null())
     did_scroll_callback_.Run();
   // The callback could potentially change the layer structure:
   // "this" may have been destroyed during the process.
 }
 
 void Layer::SetScrollClipLayerId(int clip_layer_id) {
   DCHECK(IsPropertyChangeAllowed());
   if (scroll_clip_layer_id_ == clip_layer_id)
     return;
@@ skipping 295 matching lines @@
     scoped_ptr<CopyOutputRequest> original_request = copy_requests_.take(it);
     const CopyOutputRequest& original_request_ref = *original_request;
     scoped_ptr<CopyOutputRequest> main_thread_request =
         CopyOutputRequest::CreateRelayRequest(
             original_request_ref,
             base::Bind(&PostCopyCallbackToMainThread,
                        main_thread_task_runner,
                        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);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
@@ skipping 118 matching lines @@
 // On<Property>Animated is called due to an ongoing accelerated animation.
 // Since this animation is also being run on the compositor thread, there
 // is no need to request a commit to push this value over, so the value is
 // set directly rather than by calling Set<Property>.
 void Layer::OnFilterAnimated(const FilterOperations& filters) {
   filters_ = 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) {
   // Do nothing. Scroll deltas will be sent from the compositor thread back
   // to the main thread in the same manner as during non-animated
   // compositor-driven scrolling.
 }
 
 void Layer::OnAnimationWaitingForDeletion() {
   // Animations are only deleted during PushProperties.
@@ skipping 198 matching lines @@
 
 void Layer::DidBeginTracing() {
   // We'll be dumping layer trees as part of trace, so make sure
   // PushPropertiesTo() propagates layer debug info to the impl
   // side -- otherwise this won't happen for the the layers that
   // remain unchanged since tracing started.
   SetNeedsPushProperties();
 }
 
 }  // namespace cc