[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 1 | // Copyright 2011 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
[email protected] | 556fd29 | 2013-03-18 08:03:04 | [diff] [blame] | 5 | #include "cc/trees/tree_synchronizer.h" |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 6 | |
avi | 02a4d17 | 2015-12-21 06:14:36 | [diff] [blame] | 7 | #include <stddef.h> |
| 8 | |
[email protected] | ac7c7f5 | 2012-11-08 06:26:50 | [diff] [blame] | 9 | #include <algorithm> |
[email protected] | 0e98cdd | 2013-08-23 00:44:30 | [diff] [blame] | 10 | #include <set> |
[email protected] | bf691c2 | 2013-03-26 21:15:06 | [diff] [blame] | 11 | #include <vector> |
[email protected] | ac7c7f5 | 2012-11-08 06:26:50 | [diff] [blame] | 12 | |
[email protected] | d097e24 | 2014-02-28 21:51:11 | [diff] [blame] | 13 | #include "base/format_macros.h" |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 14 | #include "base/memory/ptr_util.h" |
[email protected] | d097e24 | 2014-02-28 21:51:11 | [diff] [blame] | 15 | #include "base/strings/stringprintf.h" |
[email protected] | cc3cfaa | 2013-03-18 09:05:52 | [diff] [blame] | 16 | #include "cc/layers/layer.h" |
| 17 | #include "cc/layers/layer_impl.h" |
[email protected] | 101441ce | 2012-10-16 01:45:03 | [diff] [blame] | 18 | #include "cc/test/animation_test_common.h" |
khushalsagar | b64b360d | 2015-10-21 19:25:16 | [diff] [blame] | 19 | #include "cc/test/fake_impl_task_runner_provider.h" |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 20 | #include "cc/test/fake_layer_tree_host.h" |
hendrikw | 9b7f6d98 | 2014-11-04 22:28:35 | [diff] [blame] | 21 | #include "cc/test/fake_rendering_stats_instrumentation.h" |
danakj | ffc181a | 2016-07-22 22:48:43 | [diff] [blame] | 22 | #include "cc/test/stub_layer_tree_host_single_thread_client.h" |
[email protected] | 4e2eb35 | 2014-03-20 17:25:45 | [diff] [blame] | 23 | #include "cc/test/test_shared_bitmap_manager.h" |
danakj | cf61058 | 2015-06-16 22:48:56 | [diff] [blame] | 24 | #include "cc/test/test_task_graph_runner.h" |
trchen | dba8b150 | 2016-07-08 09:47:01 | [diff] [blame] | 25 | #include "cc/trees/effect_node.h" |
jaydasika | 13c0506 | 2016-04-01 18:12:27 | [diff] [blame] | 26 | #include "cc/trees/layer_tree_host_common.h" |
[email protected] | 556fd29 | 2013-03-18 08:03:04 | [diff] [blame] | 27 | #include "cc/trees/single_thread_proxy.h" |
khushalsagar | b64b360d | 2015-10-21 19:25:16 | [diff] [blame] | 28 | #include "cc/trees/task_runner_provider.h" |
[email protected] | 7f0c53db | 2012-10-02 00:23:18 | [diff] [blame] | 29 | #include "testing/gtest/include/gtest/gtest.h" |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 30 | |
[email protected] | ba56574 | 2012-11-10 09:29:48 | [diff] [blame] | 31 | namespace cc { |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 32 | namespace { |
| 33 | |
[email protected] | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 34 | class MockLayerImpl : public LayerImpl { |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 35 | public: |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 36 | static std::unique_ptr<MockLayerImpl> Create(LayerTreeImpl* tree_impl, |
| 37 | int layer_id) { |
| 38 | return base::WrapUnique(new MockLayerImpl(tree_impl, layer_id)); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 39 | } |
dcheng | 716bedf | 2014-10-21 09:51:08 | [diff] [blame] | 40 | ~MockLayerImpl() override { |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 41 | if (layer_impl_destruction_list_) |
| 42 | layer_impl_destruction_list_->push_back(id()); |
| 43 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 44 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 45 | void SetLayerImplDestructionList(std::vector<int>* list) { |
| 46 | layer_impl_destruction_list_ = list; |
| 47 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 48 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 49 | private: |
| 50 | MockLayerImpl(LayerTreeImpl* tree_impl, int layer_id) |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 51 | : LayerImpl(tree_impl, layer_id), layer_impl_destruction_list_(NULL) {} |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 52 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 53 | std::vector<int>* layer_impl_destruction_list_; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 54 | }; |
| 55 | |
[email protected] | 96baf3e | 2012-10-22 23:09:55 | [diff] [blame] | 56 | class MockLayer : public Layer { |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 57 | public: |
| 58 | static scoped_refptr<MockLayer> Create( |
| 59 | std::vector<int>* layer_impl_destruction_list) { |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 60 | return make_scoped_refptr(new MockLayer(layer_impl_destruction_list)); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 61 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 62 | |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 63 | std::unique_ptr<LayerImpl> CreateLayerImpl( |
| 64 | LayerTreeImpl* tree_impl) override { |
khushalsagar | b51998f | 2016-07-08 01:04:21 | [diff] [blame] | 65 | return MockLayerImpl::Create(tree_impl, id()); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 66 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 67 | |
dcheng | 716bedf | 2014-10-21 09:51:08 | [diff] [blame] | 68 | void PushPropertiesTo(LayerImpl* layer_impl) override { |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 69 | Layer::PushPropertiesTo(layer_impl); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 70 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 71 | MockLayerImpl* mock_layer_impl = static_cast<MockLayerImpl*>(layer_impl); |
| 72 | mock_layer_impl->SetLayerImplDestructionList(layer_impl_destruction_list_); |
| 73 | } |
[email protected] | d58499a | 2012-10-09 22:27:47 | [diff] [blame] | 74 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 75 | private: |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 76 | explicit MockLayer(std::vector<int>* layer_impl_destruction_list) |
| 77 | : layer_impl_destruction_list_(layer_impl_destruction_list) {} |
dcheng | 716bedf | 2014-10-21 09:51:08 | [diff] [blame] | 78 | ~MockLayer() override {} |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 79 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 80 | std::vector<int>* layer_impl_destruction_list_; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 81 | }; |
| 82 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 83 | void ExpectTreesAreIdentical(Layer* root_layer, |
| 84 | LayerImpl* root_layer_impl, |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 85 | LayerTreeImpl* tree_impl) { |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 86 | auto layer_iter = root_layer->layer_tree_host()->begin(); |
| 87 | auto layer_impl_iter = tree_impl->begin(); |
| 88 | for (; layer_iter != root_layer->layer_tree_host()->end(); |
| 89 | ++layer_iter, ++layer_impl_iter) { |
| 90 | Layer* layer = *layer_iter; |
| 91 | LayerImpl* layer_impl = *layer_impl_iter; |
| 92 | ASSERT_TRUE(layer); |
| 93 | ASSERT_TRUE(layer_impl); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 94 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 95 | EXPECT_EQ(layer->id(), layer_impl->id()); |
| 96 | EXPECT_EQ(layer_impl->layer_tree_impl(), tree_impl); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 97 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 98 | EXPECT_EQ(layer->non_fast_scrollable_region(), |
| 99 | layer_impl->non_fast_scrollable_region()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 100 | |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 101 | const EffectTree& effect_tree = tree_impl->property_trees()->effect_tree; |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 102 | if (layer->mask_layer()) { |
| 103 | SCOPED_TRACE("mask_layer"); |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 104 | int mask_layer_id = layer->mask_layer()->id(); |
| 105 | EXPECT_TRUE(tree_impl->LayerById(mask_layer_id)); |
trchen | dba8b150 | 2016-07-08 09:47:01 | [diff] [blame] | 106 | EXPECT_EQ( |
| 107 | mask_layer_id, |
| 108 | effect_tree.Node(layer_impl->effect_tree_index())->mask_layer_id); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 109 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 110 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 111 | if (layer->replica_layer()) { |
| 112 | SCOPED_TRACE("replica_layer"); |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 113 | int replica_layer_id = layer->replica_layer()->id(); |
| 114 | EXPECT_TRUE(tree_impl->LayerById(layer->replica_layer()->id())); |
trchen | dba8b150 | 2016-07-08 09:47:01 | [diff] [blame] | 115 | EXPECT_EQ( |
| 116 | replica_layer_id, |
| 117 | effect_tree.Node(layer_impl->effect_tree_index())->replica_layer_id); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 118 | if (layer->replica_layer()->mask_layer()) { |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 119 | SCOPED_TRACE("replica_mask_layer"); |
| 120 | int replica_mask_layer_id = layer->replica_layer()->mask_layer()->id(); |
| 121 | EXPECT_TRUE(tree_impl->LayerById(replica_mask_layer_id)); |
| 122 | EXPECT_EQ(replica_mask_layer_id, |
| 123 | effect_tree.Node(layer_impl->effect_tree_index()) |
trchen | dba8b150 | 2016-07-08 09:47:01 | [diff] [blame] | 124 | ->replica_mask_layer_id); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 125 | } |
| 126 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 127 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 128 | const Layer* layer_scroll_parent = layer->scroll_parent(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 129 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 130 | if (layer_scroll_parent) { |
| 131 | ASSERT_TRUE(layer_scroll_parent->scroll_children()->find(layer) != |
| 132 | layer_scroll_parent->scroll_children()->end()); |
| 133 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 134 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 135 | const Layer* layer_clip_parent = layer->clip_parent(); |
[email protected] | 0e98cdd | 2013-08-23 00:44:30 | [diff] [blame] | 136 | |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 137 | if (layer_clip_parent) { |
| 138 | const std::set<Layer*>* clip_children = |
| 139 | layer_clip_parent->clip_children(); |
| 140 | ASSERT_TRUE(clip_children->find(layer) != clip_children->end()); |
| 141 | } |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 142 | } |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 143 | } |
| 144 | |
[email protected] | c228238 | 2012-12-16 00:46:03 | [diff] [blame] | 145 | class TreeSynchronizerTest : public testing::Test { |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 146 | protected: |
danakj | 6021ec3 | 2016-07-22 22:16:08 | [diff] [blame] | 147 | TreeSynchronizerTest() |
| 148 | : host_(FakeLayerTreeHost::Create(&client_, &task_graph_runner_)) {} |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 149 | |
| 150 | bool is_equal(ScrollTree::ScrollOffsetMap map, |
| 151 | ScrollTree::ScrollOffsetMap other) { |
| 152 | if (map.size() != other.size()) |
| 153 | return false; |
| 154 | for (auto& map_entry : map) { |
| 155 | if (other.find(map_entry.first) == other.end()) |
| 156 | return false; |
| 157 | SyncedScrollOffset& from_map = *map_entry.second.get(); |
| 158 | SyncedScrollOffset& from_other = *other[map_entry.first].get(); |
| 159 | if (from_map.PendingBase() != from_other.PendingBase() || |
| 160 | from_map.ActiveBase() != from_other.ActiveBase() || |
| 161 | from_map.Delta() != from_other.Delta() || |
| 162 | from_map.PendingDelta().get() != from_other.PendingDelta().get()) |
| 163 | return false; |
| 164 | } |
| 165 | return true; |
| 166 | } |
danakj | 6021ec3 | 2016-07-22 22:16:08 | [diff] [blame] | 167 | |
| 168 | FakeLayerTreeHostClient client_; |
danakj | ffc181a | 2016-07-22 22:48:43 | [diff] [blame] | 169 | StubLayerTreeHostSingleThreadClient single_thread_client_; |
danakj | 6021ec3 | 2016-07-22 22:16:08 | [diff] [blame] | 170 | TestTaskGraphRunner task_graph_runner_; |
| 171 | std::unique_ptr<FakeLayerTreeHost> host_; |
[email protected] | c228238 | 2012-12-16 00:46:03 | [diff] [blame] | 172 | }; |
| 173 | |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 174 | // Attempts to synchronizes a null tree. This should not crash, and should |
| 175 | // return a null tree. |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 176 | TEST_F(TreeSynchronizerTest, SyncNullTree) { |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 177 | TreeSynchronizer::SynchronizeTrees(static_cast<Layer*>(NULL), |
| 178 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 179 | EXPECT_TRUE(!host_->active_tree()->root_layer_for_testing()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 180 | } |
| 181 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 182 | // Constructs a very simple tree and synchronizes it without trying to reuse any |
| 183 | // preexisting layers. |
| 184 | TEST_F(TreeSynchronizerTest, SyncSimpleTreeFromEmpty) { |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 185 | scoped_refptr<Layer> layer_tree_root = Layer::Create(); |
| 186 | layer_tree_root->AddChild(Layer::Create()); |
| 187 | layer_tree_root->AddChild(Layer::Create()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 188 | |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 189 | host_->SetRootLayer(layer_tree_root); |
| 190 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 191 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 192 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 193 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 194 | ExpectTreesAreIdentical(layer_tree_root.get(), |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 195 | host_->active_tree()->root_layer_for_testing(), |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 196 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 197 | } |
| 198 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 199 | // Constructs a very simple tree and synchronizes it attempting to reuse some |
| 200 | // layers |
| 201 | TEST_F(TreeSynchronizerTest, SyncSimpleTreeReusingLayers) { |
| 202 | std::vector<int> layer_impl_destruction_list; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 203 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 204 | scoped_refptr<Layer> layer_tree_root = |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 205 | MockLayer::Create(&layer_impl_destruction_list); |
| 206 | layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
| 207 | layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 208 | int second_layer_impl_id = layer_tree_root->children()[1]->id(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 209 | |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 210 | host_->SetRootLayer(layer_tree_root); |
| 211 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 212 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 213 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 214 | LayerImpl* layer_impl_tree_root = |
| 215 | host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 216 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 217 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 218 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 219 | // We have to push properties to pick up the destruction list pointer. |
jaydasika | 9234e40 | 2016-03-21 20:44:22 | [diff] [blame] | 220 | TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(), |
| 221 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 222 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 223 | // Add a new layer to the Layer side |
loyso | a6edaaff | 2015-05-25 03:26:44 | [diff] [blame] | 224 | layer_tree_root->children()[0]->AddChild( |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 225 | MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 226 | // Remove one. |
| 227 | layer_tree_root->children()[1]->RemoveFromParent(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 228 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 229 | // Synchronize again. After the sync the trees should be equivalent and we |
| 230 | // should have created and destroyed one LayerImpl. |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 231 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 232 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 233 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 234 | |
| 235 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 236 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 237 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 238 | ASSERT_EQ(1u, layer_impl_destruction_list.size()); |
| 239 | EXPECT_EQ(second_layer_impl_id, layer_impl_destruction_list[0]); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 240 | |
rockot | 2176f92 | 2016-06-08 19:18:32 | [diff] [blame] | 241 | host_->active_tree()->DetachLayers(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 242 | } |
| 243 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 244 | // Constructs a very simple tree and checks that a stacking-order change is |
| 245 | // tracked properly. |
| 246 | TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndTrackStackingOrderChange) { |
| 247 | std::vector<int> layer_impl_destruction_list; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 248 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 249 | // Set up the tree and sync once. child2 needs to be synced here, too, even |
| 250 | // though we remove it to set up the intended scenario. |
| 251 | scoped_refptr<Layer> layer_tree_root = |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 252 | MockLayer::Create(&layer_impl_destruction_list); |
| 253 | scoped_refptr<Layer> child2 = MockLayer::Create(&layer_impl_destruction_list); |
| 254 | layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 255 | layer_tree_root->AddChild(child2); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 256 | int child1_id = layer_tree_root->children()[0]->id(); |
| 257 | int child2_id = layer_tree_root->children()[1]->id(); |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 258 | |
| 259 | host_->SetRootLayer(layer_tree_root); |
| 260 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 261 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 262 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 263 | LayerImpl* layer_impl_tree_root = |
| 264 | host_->active_tree()->root_layer_for_testing(); |
jaydasika | ef64f9e4 | 2016-03-12 01:08:18 | [diff] [blame] | 265 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 266 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 267 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 268 | // We have to push properties to pick up the destruction list pointer. |
jaydasika | 9234e40 | 2016-03-21 20:44:22 | [diff] [blame] | 269 | TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(), |
| 270 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 271 | |
jaydasika | d6f778b | 2016-05-19 22:51:26 | [diff] [blame] | 272 | host_->active_tree()->ResetAllChangeTracking(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 273 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 274 | // re-insert the layer and sync again. |
| 275 | child2->RemoveFromParent(); |
| 276 | layer_tree_root->AddChild(child2); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 277 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 278 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 279 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
jaydasika | ef64f9e4 | 2016-03-12 01:08:18 | [diff] [blame] | 280 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 281 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 282 | |
jaydasika | 9234e40 | 2016-03-21 20:44:22 | [diff] [blame] | 283 | TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(), |
| 284 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 285 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 286 | // Check that the impl thread properly tracked the change. |
| 287 | EXPECT_FALSE(layer_impl_tree_root->LayerPropertyChanged()); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 288 | EXPECT_FALSE( |
| 289 | host_->active_tree()->LayerById(child1_id)->LayerPropertyChanged()); |
| 290 | EXPECT_TRUE( |
| 291 | host_->active_tree()->LayerById(child2_id)->LayerPropertyChanged()); |
rockot | 2176f92 | 2016-06-08 19:18:32 | [diff] [blame] | 292 | host_->active_tree()->DetachLayers(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 293 | } |
| 294 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 295 | TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndProperties) { |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 296 | scoped_refptr<Layer> layer_tree_root = Layer::Create(); |
| 297 | layer_tree_root->AddChild(Layer::Create()); |
| 298 | layer_tree_root->AddChild(Layer::Create()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 299 | |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 300 | host_->SetRootLayer(layer_tree_root); |
| 301 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 302 | // Pick some random properties to set. The values are not important, we're |
| 303 | // just testing that at least some properties are making it through. |
| 304 | gfx::PointF root_position = gfx::PointF(2.3f, 7.4f); |
| 305 | layer_tree_root->SetPosition(root_position); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 306 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 307 | gfx::Size second_child_bounds = gfx::Size(25, 53); |
| 308 | layer_tree_root->children()[1]->SetBounds(second_child_bounds); |
[email protected] | 445881f | 2013-04-16 01:11:59 | [diff] [blame] | 309 | layer_tree_root->children()[1]->SavePaintProperties(); |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 310 | int second_child_id = layer_tree_root->children()[1]->id(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 311 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 312 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 313 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 314 | LayerImpl* layer_impl_tree_root = |
| 315 | host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 316 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 317 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 318 | |
jaydasika | 9234e40 | 2016-03-21 20:44:22 | [diff] [blame] | 319 | TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(), |
| 320 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 321 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 322 | // Check that the property values we set on the Layer tree are reflected in |
| 323 | // the LayerImpl tree. |
| 324 | gfx::PointF root_layer_impl_position = layer_impl_tree_root->position(); |
| 325 | EXPECT_EQ(root_position.x(), root_layer_impl_position.x()); |
| 326 | EXPECT_EQ(root_position.y(), root_layer_impl_position.y()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 327 | |
bokan | cccfde7 | 2014-10-08 15:15:22 | [diff] [blame] | 328 | gfx::Size second_layer_impl_child_bounds = |
jaydasika | 4b0fd751 | 2016-06-09 18:12:53 | [diff] [blame] | 329 | layer_impl_tree_root->layer_tree_impl() |
| 330 | ->LayerById(second_child_id) |
| 331 | ->bounds(); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 332 | EXPECT_EQ(second_child_bounds.width(), |
| 333 | second_layer_impl_child_bounds.width()); |
| 334 | EXPECT_EQ(second_child_bounds.height(), |
| 335 | second_layer_impl_child_bounds.height()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 336 | } |
| 337 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 338 | TEST_F(TreeSynchronizerTest, ReuseLayerImplsAfterStructuralChange) { |
| 339 | std::vector<int> layer_impl_destruction_list; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 340 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 341 | // Set up a tree with this sort of structure: |
| 342 | // root --- A --- B ---+--- C |
| 343 | // | |
| 344 | // +--- D |
| 345 | scoped_refptr<Layer> layer_tree_root = |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 346 | MockLayer::Create(&layer_impl_destruction_list); |
| 347 | layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 348 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 349 | scoped_refptr<Layer> layer_a = layer_tree_root->children()[0]; |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 350 | layer_a->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 351 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 352 | scoped_refptr<Layer> layer_b = layer_a->children()[0]; |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 353 | layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 354 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 355 | scoped_refptr<Layer> layer_c = layer_b->children()[0]; |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 356 | layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list)); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 357 | scoped_refptr<Layer> layer_d = layer_b->children()[1]; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 358 | |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 359 | host_->SetRootLayer(layer_tree_root); |
| 360 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 361 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 362 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 363 | LayerImpl* layer_impl_tree_root = |
| 364 | host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 365 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 366 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 367 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 368 | // We have to push properties to pick up the destruction list pointer. |
jaydasika | 9234e40 | 2016-03-21 20:44:22 | [diff] [blame] | 369 | TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(), |
| 370 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 371 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 372 | // Now restructure the tree to look like this: |
| 373 | // root --- D ---+--- A |
| 374 | // | |
| 375 | // +--- C --- B |
| 376 | layer_tree_root->RemoveAllChildren(); |
| 377 | layer_d->RemoveAllChildren(); |
| 378 | layer_tree_root->AddChild(layer_d); |
| 379 | layer_a->RemoveAllChildren(); |
| 380 | layer_d->AddChild(layer_a); |
| 381 | layer_c->RemoveAllChildren(); |
| 382 | layer_d->AddChild(layer_c); |
| 383 | layer_b->RemoveAllChildren(); |
| 384 | layer_c->AddChild(layer_b); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 385 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 386 | // After another synchronize our trees should match and we should not have |
| 387 | // destroyed any LayerImpls |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 388 | TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), |
| 389 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 390 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 391 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 392 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 393 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 394 | EXPECT_EQ(0u, layer_impl_destruction_list.size()); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 395 | |
rockot | 2176f92 | 2016-06-08 19:18:32 | [diff] [blame] | 396 | host_->active_tree()->DetachLayers(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 397 | } |
| 398 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 399 | // Constructs a very simple tree, synchronizes it, then synchronizes to a |
| 400 | // totally new tree. All layers from the old tree should be deleted. |
| 401 | TEST_F(TreeSynchronizerTest, SyncSimpleTreeThenDestroy) { |
| 402 | std::vector<int> layer_impl_destruction_list; |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 403 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 404 | scoped_refptr<Layer> old_layer_tree_root = |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 405 | MockLayer::Create(&layer_impl_destruction_list); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 406 | old_layer_tree_root->AddChild( |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 407 | MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 408 | old_layer_tree_root->AddChild( |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 409 | MockLayer::Create(&layer_impl_destruction_list)); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 410 | |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 411 | host_->SetRootLayer(old_layer_tree_root); |
| 412 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 413 | int old_tree_root_layer_id = old_layer_tree_root->id(); |
| 414 | int old_tree_first_child_layer_id = old_layer_tree_root->children()[0]->id(); |
| 415 | int old_tree_second_child_layer_id = old_layer_tree_root->children()[1]->id(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 416 | |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 417 | TreeSynchronizer::SynchronizeTrees(old_layer_tree_root.get(), |
| 418 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 419 | LayerImpl* layer_impl_tree_root = |
| 420 | host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 421 | ExpectTreesAreIdentical(old_layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 422 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 423 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 424 | // We have to push properties to pick up the destruction list pointer. |
jaydasika | 9234e40 | 2016-03-21 20:44:22 | [diff] [blame] | 425 | TreeSynchronizer::PushLayerProperties(old_layer_tree_root->layer_tree_host(), |
| 426 | host_->active_tree()); |
[email protected] | 5c4824e1 | 2013-01-12 16:34:53 | [diff] [blame] | 427 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 428 | // Remove all children on the Layer side. |
| 429 | old_layer_tree_root->RemoveAllChildren(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 430 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 431 | // Synchronize again. After the sync all LayerImpls from the old tree should |
| 432 | // be deleted. |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 433 | scoped_refptr<Layer> new_layer_tree_root = Layer::Create(); |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 434 | host_->SetRootLayer(new_layer_tree_root); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 435 | |
| 436 | TreeSynchronizer::SynchronizeTrees(new_layer_tree_root.get(), |
| 437 | host_->active_tree()); |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 438 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 439 | ExpectTreesAreIdentical(new_layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 440 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 441 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 442 | ASSERT_EQ(3u, layer_impl_destruction_list.size()); |
[email protected] | 2cdbdba | 2012-10-28 13:15:05 | [diff] [blame] | 443 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 444 | EXPECT_TRUE(std::find(layer_impl_destruction_list.begin(), |
| 445 | layer_impl_destruction_list.end(), |
| 446 | old_tree_root_layer_id) != |
| 447 | layer_impl_destruction_list.end()); |
| 448 | EXPECT_TRUE(std::find(layer_impl_destruction_list.begin(), |
| 449 | layer_impl_destruction_list.end(), |
| 450 | old_tree_first_child_layer_id) != |
| 451 | layer_impl_destruction_list.end()); |
| 452 | EXPECT_TRUE(std::find(layer_impl_destruction_list.begin(), |
| 453 | layer_impl_destruction_list.end(), |
| 454 | old_tree_second_child_layer_id) != |
| 455 | layer_impl_destruction_list.end()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 456 | } |
| 457 | |
| 458 | // Constructs+syncs a tree with mask, replica, and replica mask layers. |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 459 | TEST_F(TreeSynchronizerTest, SyncMaskReplicaAndReplicaMaskLayers) { |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 460 | scoped_refptr<Layer> layer_tree_root = Layer::Create(); |
| 461 | layer_tree_root->AddChild(Layer::Create()); |
| 462 | layer_tree_root->AddChild(Layer::Create()); |
| 463 | layer_tree_root->AddChild(Layer::Create()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 464 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 465 | // First child gets a mask layer. |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 466 | scoped_refptr<Layer> mask_layer = Layer::Create(); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 467 | layer_tree_root->children()[0]->SetMaskLayer(mask_layer.get()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 468 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 469 | // Second child gets a replica layer. |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 470 | scoped_refptr<Layer> replica_layer = Layer::Create(); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 471 | layer_tree_root->children()[1]->SetReplicaLayer(replica_layer.get()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 472 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 473 | // Third child gets a replica layer with a mask layer. |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 474 | scoped_refptr<Layer> replica_layer_with_mask = Layer::Create(); |
| 475 | scoped_refptr<Layer> replica_mask_layer = Layer::Create(); |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 476 | replica_layer_with_mask->SetMaskLayer(replica_mask_layer.get()); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 477 | layer_tree_root->children()[2]->SetReplicaLayer( |
| 478 | replica_layer_with_mask.get()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 479 | |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 480 | host_->SetRootLayer(layer_tree_root); |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 481 | host_->BuildPropertyTreesForTesting(); |
| 482 | host_->CommitAndCreateLayerImplTree(); |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 483 | |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 484 | LayerImpl* layer_impl_tree_root = |
| 485 | host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 486 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 487 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 488 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 489 | // Remove the mask layer. |
| 490 | layer_tree_root->children()[0]->SetMaskLayer(NULL); |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 491 | host_->BuildPropertyTreesForTesting(); |
| 492 | host_->CommitAndCreateLayerImplTree(); |
| 493 | |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 494 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 495 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 496 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 497 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 498 | // Remove the replica layer. |
| 499 | layer_tree_root->children()[1]->SetReplicaLayer(NULL); |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 500 | host_->BuildPropertyTreesForTesting(); |
| 501 | host_->CommitAndCreateLayerImplTree(); |
| 502 | |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 503 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 504 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 505 | host_->active_tree()); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 506 | |
[email protected] | b5651c2 | 2013-03-14 15:06:33 | [diff] [blame] | 507 | // Remove the replica mask. |
| 508 | replica_layer_with_mask->SetMaskLayer(NULL); |
ajuma | 1d4026a3 | 2016-06-14 13:18:50 | [diff] [blame] | 509 | host_->BuildPropertyTreesForTesting(); |
| 510 | host_->CommitAndCreateLayerImplTree(); |
| 511 | |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 512 | layer_impl_tree_root = host_->active_tree()->root_layer_for_testing(); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 513 | ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, |
[email protected] | f4e25f9 | 2013-07-13 20:54:53 | [diff] [blame] | 514 | host_->active_tree()); |
vollick | 83fbfc8 | 2016-03-22 18:33:27 | [diff] [blame] | 515 | |
rockot | 2176f92 | 2016-06-08 19:18:32 | [diff] [blame] | 516 | host_->active_tree()->DetachLayers(); |
[email protected] | c0dd24c | 2012-08-30 23:25:27 | [diff] [blame] | 517 | } |
| 518 | |
sunxd | 54e08e9d | 2016-02-22 23:01:28 | [diff] [blame] | 519 | TEST_F(TreeSynchronizerTest, SynchronizeCurrentlyScrollingNode) { |
| 520 | LayerTreeSettings settings; |
| 521 | FakeLayerTreeHostImplClient client; |
| 522 | FakeImplTaskRunnerProvider task_runner_provider; |
| 523 | FakeRenderingStatsInstrumentation stats_instrumentation; |
| 524 | TestSharedBitmapManager shared_bitmap_manager; |
| 525 | TestTaskGraphRunner task_graph_runner; |
| 526 | FakeLayerTreeHostImpl* host_impl = host_->host_impl(); |
| 527 | host_impl->CreatePendingTree(); |
| 528 | |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 529 | scoped_refptr<Layer> layer_tree_root = Layer::Create(); |
| 530 | scoped_refptr<Layer> scroll_clip_layer = Layer::Create(); |
| 531 | scoped_refptr<Layer> scroll_layer = Layer::Create(); |
| 532 | scoped_refptr<Layer> transient_scroll_clip_layer = Layer::Create(); |
| 533 | scoped_refptr<Layer> transient_scroll_layer = Layer::Create(); |
sunxd | 54e08e9d | 2016-02-22 23:01:28 | [diff] [blame] | 534 | |
| 535 | layer_tree_root->AddChild(transient_scroll_clip_layer); |
| 536 | transient_scroll_clip_layer->AddChild(transient_scroll_layer); |
| 537 | transient_scroll_layer->AddChild(scroll_clip_layer); |
| 538 | scroll_clip_layer->AddChild(scroll_layer); |
| 539 | |
| 540 | transient_scroll_layer->SetScrollClipLayerId( |
| 541 | transient_scroll_clip_layer->id()); |
| 542 | scroll_layer->SetScrollClipLayerId(scroll_clip_layer->id()); |
| 543 | host_->SetRootLayer(layer_tree_root); |
| 544 | host_->BuildPropertyTreesForTesting(); |
| 545 | host_->CommitAndCreatePendingTree(); |
| 546 | host_impl->ActivateSyncTree(); |
| 547 | |
| 548 | ExpectTreesAreIdentical(layer_tree_root.get(), |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 549 | host_impl->active_tree()->root_layer_for_testing(), |
sunxd | 54e08e9d | 2016-02-22 23:01:28 | [diff] [blame] | 550 | host_impl->active_tree()); |
| 551 | |
| 552 | host_impl->active_tree()->SetCurrentlyScrollingLayer( |
vollick | cb3f6b1 | 2016-03-01 23:44:10 | [diff] [blame] | 553 | host_impl->active_tree()->LayerById(scroll_layer->id())); |
sunxd | 54e08e9d | 2016-02-22 23:01:28 | [diff] [blame] | 554 | transient_scroll_layer->SetScrollClipLayerId(Layer::INVALID_ID); |
| 555 | host_->BuildPropertyTreesForTesting(); |
| 556 | |
| 557 | host_impl->CreatePendingTree(); |
| 558 | host_->CommitAndCreatePendingTree(); |
| 559 | host_impl->ActivateSyncTree(); |
| 560 | |
| 561 | EXPECT_EQ(scroll_layer->id(), |
| 562 | host_impl->active_tree()->CurrentlyScrollingLayer()->id()); |
| 563 | } |
| 564 | |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 565 | TEST_F(TreeSynchronizerTest, SynchronizeScrollTreeScrollOffsetMap) { |
danakj | ffc181a | 2016-07-22 22:48:43 | [diff] [blame] | 566 | host_->InitializeSingleThreaded(&single_thread_client_, |
| 567 | base::ThreadTaskRunnerHandle::Get(), nullptr); |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 568 | LayerTreeSettings settings; |
| 569 | FakeLayerTreeHostImplClient client; |
| 570 | FakeImplTaskRunnerProvider task_runner_provider; |
| 571 | FakeRenderingStatsInstrumentation stats_instrumentation; |
| 572 | TestSharedBitmapManager shared_bitmap_manager; |
| 573 | TestTaskGraphRunner task_graph_runner; |
| 574 | FakeLayerTreeHostImpl* host_impl = host_->host_impl(); |
| 575 | host_impl->CreatePendingTree(); |
| 576 | |
loyso | 0940d41 | 2016-03-14 01:30:31 | [diff] [blame] | 577 | scoped_refptr<Layer> layer_tree_root = Layer::Create(); |
| 578 | scoped_refptr<Layer> scroll_clip_layer = Layer::Create(); |
| 579 | scoped_refptr<Layer> scroll_layer = Layer::Create(); |
| 580 | scoped_refptr<Layer> transient_scroll_clip_layer = Layer::Create(); |
| 581 | scoped_refptr<Layer> transient_scroll_layer = Layer::Create(); |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 582 | |
| 583 | layer_tree_root->AddChild(transient_scroll_clip_layer); |
| 584 | transient_scroll_clip_layer->AddChild(transient_scroll_layer); |
| 585 | transient_scroll_layer->AddChild(scroll_clip_layer); |
| 586 | scroll_clip_layer->AddChild(scroll_layer); |
| 587 | |
| 588 | transient_scroll_layer->SetScrollClipLayerId( |
| 589 | transient_scroll_clip_layer->id()); |
| 590 | scroll_layer->SetScrollClipLayerId(scroll_clip_layer->id()); |
| 591 | transient_scroll_layer->SetScrollOffset(gfx::ScrollOffset(1, 2)); |
| 592 | scroll_layer->SetScrollOffset(gfx::ScrollOffset(10, 20)); |
| 593 | |
| 594 | host_->SetRootLayer(layer_tree_root); |
| 595 | host_->BuildPropertyTreesForTesting(); |
| 596 | host_->CommitAndCreatePendingTree(); |
| 597 | host_impl->ActivateSyncTree(); |
| 598 | |
| 599 | ExpectTreesAreIdentical(layer_tree_root.get(), |
jaydasika | bf1875a | 2016-06-28 03:39:59 | [diff] [blame] | 600 | host_impl->active_tree()->root_layer_for_testing(), |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 601 | host_impl->active_tree()); |
| 602 | |
| 603 | // After the initial commit, scroll_offset_map in scroll_tree is expected to |
| 604 | // have one entry for scroll_layer and one entry for transient_scroll_layer, |
| 605 | // the pending base and active base must be the same at this stage. |
| 606 | ScrollTree::ScrollOffsetMap scroll_offset_map; |
| 607 | scroll_offset_map[scroll_layer->id()] = new SyncedScrollOffset; |
| 608 | scroll_offset_map[transient_scroll_layer->id()] = new SyncedScrollOffset; |
| 609 | scroll_offset_map[scroll_layer->id()]->PushFromMainThread( |
| 610 | scroll_layer->scroll_offset()); |
| 611 | scroll_offset_map[scroll_layer->id()]->PushPendingToActive(); |
| 612 | scroll_offset_map[transient_scroll_layer->id()]->PushFromMainThread( |
| 613 | transient_scroll_layer->scroll_offset()); |
| 614 | scroll_offset_map[transient_scroll_layer->id()]->PushPendingToActive(); |
| 615 | EXPECT_TRUE( |
| 616 | is_equal(scroll_offset_map, host_impl->active_tree() |
| 617 | ->property_trees() |
| 618 | ->scroll_tree.scroll_offset_map())); |
| 619 | |
| 620 | // Set ScrollOffset active delta: gfx::ScrollOffset(10, 10) |
| 621 | LayerImpl* scroll_layer_impl = |
| 622 | host_impl->active_tree()->LayerById(scroll_layer->id()); |
| 623 | ScrollTree& scroll_tree = |
| 624 | host_impl->active_tree()->property_trees()->scroll_tree; |
sunxd | c044b11a | 2016-03-16 16:23:20 | [diff] [blame] | 625 | scroll_tree.SetScrollOffset(scroll_layer_impl->id(), |
| 626 | gfx::ScrollOffset(20, 30)); |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 627 | |
| 628 | // Pull ScrollOffset delta for main thread, and change offset on main thread |
danakj | 60bc3bc | 2016-04-09 00:24:48 | [diff] [blame] | 629 | std::unique_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet()); |
bokan | 4222c27 | 2016-07-18 17:24:54 | [diff] [blame] | 630 | scroll_tree.CollectScrollDeltas(scroll_info.get(), Layer::INVALID_ID); |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 631 | host_->proxy()->SetNeedsCommit(); |
| 632 | host_->ApplyScrollAndScale(scroll_info.get()); |
| 633 | EXPECT_EQ(gfx::ScrollOffset(20, 30), scroll_layer->scroll_offset()); |
| 634 | scroll_layer->SetScrollOffset(gfx::ScrollOffset(100, 100)); |
| 635 | |
| 636 | // More update to ScrollOffset active delta: gfx::ScrollOffset(20, 20) |
sunxd | c044b11a | 2016-03-16 16:23:20 | [diff] [blame] | 637 | scroll_tree.SetScrollOffset(scroll_layer_impl->id(), |
| 638 | gfx::ScrollOffset(40, 50)); |
sunxd | c36713a | 2016-03-03 22:31:10 | [diff] [blame] | 639 | host_impl->active_tree()->SetCurrentlyScrollingLayer(scroll_layer_impl); |
| 640 | |
| 641 | // Make one layer unscrollable so that scroll tree topology changes |
| 642 | transient_scroll_layer->SetScrollClipLayerId(Layer::INVALID_ID); |
| 643 | host_->BuildPropertyTreesForTesting(); |
| 644 | |
| 645 | host_impl->CreatePendingTree(); |
| 646 | host_->CommitAndCreatePendingTree(); |
| 647 | host_impl->ActivateSyncTree(); |
| 648 | |
| 649 | EXPECT_EQ(scroll_layer->id(), |
| 650 | host_impl->active_tree()->CurrentlyScrollingLayer()->id()); |
| 651 | scroll_offset_map.erase(transient_scroll_layer->id()); |
| 652 | scroll_offset_map[scroll_layer->id()]->SetCurrent(gfx::ScrollOffset(20, 30)); |
| 653 | scroll_offset_map[scroll_layer->id()]->PullDeltaForMainThread(); |
| 654 | scroll_offset_map[scroll_layer->id()]->SetCurrent(gfx::ScrollOffset(40, 50)); |
| 655 | scroll_offset_map[scroll_layer->id()]->PushFromMainThread( |
| 656 | gfx::ScrollOffset(100, 100)); |
| 657 | scroll_offset_map[scroll_layer->id()]->PushPendingToActive(); |
| 658 | EXPECT_TRUE(is_equal(scroll_offset_map, scroll_tree.scroll_offset_map())); |
| 659 | } |
| 660 | |
sunxd | f468675e | 2016-06-30 23:56:18 | [diff] [blame] | 661 | TEST_F(TreeSynchronizerTest, RefreshPropertyTreesCachedData) { |
danakj | ffc181a | 2016-07-22 22:48:43 | [diff] [blame] | 662 | host_->InitializeSingleThreaded(&single_thread_client_, |
| 663 | base::ThreadTaskRunnerHandle::Get(), nullptr); |
sunxd | f468675e | 2016-06-30 23:56:18 | [diff] [blame] | 664 | LayerTreeSettings settings; |
| 665 | FakeLayerTreeHostImplClient client; |
| 666 | FakeImplTaskRunnerProvider task_runner_provider; |
| 667 | FakeRenderingStatsInstrumentation stats_instrumentation; |
| 668 | TestSharedBitmapManager shared_bitmap_manager; |
| 669 | TestTaskGraphRunner task_graph_runner; |
| 670 | FakeLayerTreeHostImpl* host_impl = host_->host_impl(); |
| 671 | host_impl->CreatePendingTree(); |
| 672 | |
| 673 | scoped_refptr<Layer> layer_tree_root = Layer::Create(); |
| 674 | scoped_refptr<Layer> transform_layer = Layer::Create(); |
| 675 | |
| 676 | gfx::Transform scale_transform; |
| 677 | scale_transform.Scale3d(2.f, 2.f, 2.f); |
| 678 | // Force adding a transform node for the layer. |
| 679 | transform_layer->SetTransform(scale_transform); |
| 680 | |
| 681 | layer_tree_root->AddChild(transform_layer); |
| 682 | |
| 683 | host_->SetRootLayer(layer_tree_root); |
| 684 | host_->BuildPropertyTreesForTesting(); |
| 685 | host_->CommitAndCreatePendingTree(); |
| 686 | host_impl->ActivateSyncTree(); |
| 687 | |
| 688 | // This arbitrarily set the animation scale for transform_layer and see if it |
| 689 | // is |
| 690 | // refreshed when pushing layer trees. |
| 691 | host_impl->active_tree()->property_trees()->SetAnimationScalesForTesting( |
| 692 | transform_layer->transform_tree_index(), 10.f, 10.f); |
| 693 | EXPECT_EQ( |
| 694 | CombinedAnimationScale(10.f, 10.f), |
| 695 | host_impl->active_tree()->property_trees()->GetAnimationScales( |
| 696 | transform_layer->transform_tree_index(), host_impl->active_tree())); |
| 697 | |
| 698 | host_impl->CreatePendingTree(); |
| 699 | host_->CommitAndCreatePendingTree(); |
| 700 | host_impl->ActivateSyncTree(); |
| 701 | EXPECT_EQ( |
| 702 | CombinedAnimationScale(0.f, 0.f), |
| 703 | host_impl->active_tree()->property_trees()->GetAnimationScales( |
| 704 | transform_layer->transform_tree_index(), host_impl->active_tree())); |
| 705 | } |
| 706 | |
[email protected] | ba56574 | 2012-11-10 09:29:48 | [diff] [blame] | 707 | } // namespace |
| 708 | } // namespace cc |