cc: Commit property trees to the compositor thread

cc/trees/layer_tree_host_unittest.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_host.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 3267 matching lines @@
     return new PushPropertiesCountingLayer();
   }
 
   void PushPropertiesTo(LayerImpl* layer) override {
     Layer::PushPropertiesTo(layer);
     push_properties_count_++;
     if (persist_needs_push_properties_)
       needs_push_properties_ = true;
   }
 
+  // Something to make this layer push properties, but no other layer.
+  void MakePushProperties() { SetContentsOpaque(!contents_opaque()); }
+
   scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl) override {
     return PushPropertiesCountingLayerImpl::Create(tree_impl, id());
   }
 
   void SetDrawsContent(bool draws_content) { SetIsDrawable(draws_content); }
 
   size_t push_properties_count() const { return push_properties_count_; }
   void reset_push_properties_count() { push_properties_count_ = 0; }
 
   void set_persist_needs_push_properties(bool persist) {
@@ skipping 39 matching lines @@
     child2_->AddChild(leaf_always_pushing_layer_);
 
     other_root_ = PushPropertiesCountingLayer::Create();
     other_root_->CreateRenderSurface();
 
     // Don't set the root layer here.
     LayerTreeHostTest::SetupTree();
   }
 
   void DidCommitAndDrawFrame() override {
+    EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count())
+        << "num_commits: " << num_commits_;
+    EXPECT_EQ(expected_push_properties_child_, child_->push_properties_count())
+        << "num_commits: " << num_commits_;
+    EXPECT_EQ(expected_push_properties_grandchild_,
+              grandchild_->push_properties_count())
+        << "num_commits: " << num_commits_;
+    EXPECT_EQ(expected_push_properties_child2_,
+              child2_->push_properties_count())
+        << "num_commits: " << num_commits_;
+    EXPECT_EQ(expected_push_properties_other_root_,
+              other_root_->push_properties_count())
+        << "num_commits: " << num_commits_;
+    EXPECT_EQ(expected_push_properties_leaf_layer_,
+              leaf_always_pushing_layer_->push_properties_count())
+        << "num_commits: " << num_commits_;
+
     ++num_commits_;
 
-    EXPECT_EQ(expected_push_properties_root_, root_->push_properties_count());
-    EXPECT_EQ(expected_push_properties_child_, child_->push_properties_count());
-    EXPECT_EQ(expected_push_properties_grandchild_,
-              grandchild_->push_properties_count());
-    EXPECT_EQ(expected_push_properties_child2_,
-              child2_->push_properties_count());
-    EXPECT_EQ(expected_push_properties_other_root_,
-              other_root_->push_properties_count());
-    EXPECT_EQ(expected_push_properties_leaf_layer_,
-              leaf_always_pushing_layer_->push_properties_count());
-
     // The scrollbar layer always needs to be pushed.
     if (root_->layer_tree_host()) {
       EXPECT_TRUE(root_->descendant_needs_push_properties());
       EXPECT_FALSE(root_->needs_push_properties());
     }
     if (child2_->layer_tree_host()) {
       EXPECT_TRUE(child2_->descendant_needs_push_properties());
       EXPECT_FALSE(child2_->needs_push_properties());
     }
     if (leaf_always_pushing_layer_->layer_tree_host()) {
@@ skipping 68 matching lines @@
         break;
       case 10:
         layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
         // No layers need commit.
         break;
       case 11:
         layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.8f, 1.1f);
         // No layers need commit.
         break;
       case 12:
-        child_->SetPosition(gfx::Point(1, 1));

[enne (OOO), 2015/04/17 20:59:36]

This code used to adjust the offset of children which would cause a property
push.

This in practice will cause more push properties when any parent moves around.

Alternatively, maybe "offset from parent" is a draw property-style piece of data
that should be recomputed on the compositor thread?

[ajuma, 2015/04/17 22:53:11]

If these extra pushes turn out to be costly, perhaps another alternative would
be to have a finer-grained PushPropertyTreeProperties instead of pushing all the
properties? My hand-wavy guess is that this would turn out to be cheaper than
re-computing all the offsets on the compositor side (since pushing would mean
visiting some of the layers when offsets change and copying an offset at each
visited layer, but re-computing on the compositor side would involve visiting
all of the layers after every commit and doing some math that's more complex
that just copying an offset).

+        child_->MakePushProperties();
         // The modified layer needs commit
         ++expected_push_properties_child_;
         break;
       case 13:
-        child2_->SetPosition(gfx::Point(1, 1));
+        child2_->MakePushProperties();
         // The modified layer needs commit
         ++expected_push_properties_child2_;
         break;
       case 14:
         child_->RemoveFromParent();
         root_->AddChild(child_);
         // Layers added to the tree get committed.
         ++expected_push_properties_child_;
         ++expected_push_properties_grandchild_;
         break;
       case 15:
-        grandchild_->SetPosition(gfx::Point(1, 1));
+        grandchild_->MakePushProperties();
         // The modified layer needs commit
         ++expected_push_properties_grandchild_;
         break;
       case 16:
         // SetNeedsDisplay does not always set needs commit (so call it
         // explicitly), but is a property change.
         child_->SetNeedsDisplay();
         ++expected_push_properties_child_;
         layer_tree_host()->SetNeedsCommit();
         break;
@@ skipping 3467 matching lines @@
   void AfterTest() override {}
 
   scoped_refptr<FakePictureLayer> content_child_layer_;
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeTestReflectionMaskLayerForSurfaceWithUnclippedChild);
 
 }  // namespace cc