| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 5 #include "cc/trees/damage_tracker.h" | |
| 6 | |
| 7 #include "cc/base/math_util.h" | |
| 8 #include "cc/layers/layer_impl.h" | |
| 9 #include "cc/output/filter_operation.h" | |
| 10 #include "cc/output/filter_operations.h" | |
| 11 #include "cc/test/fake_impl_proxy.h" | |
| 12 #include "cc/test/fake_layer_tree_host_impl.h" | |
| 13 #include "cc/test/geometry_test_utils.h" | |
| 14 #include "cc/test/test_shared_bitmap_manager.h" | |
| 15 #include "cc/test/test_task_graph_runner.h" | |
| 16 #include "cc/trees/layer_tree_host_common.h" | |
| 17 #include "cc/trees/single_thread_proxy.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 #include "third_party/skia/include/effects/SkBlurImageFilter.h" | |
| 20 #include "ui/gfx/geometry/quad_f.h" | |
| 21 #include "ui/gfx/geometry/rect_conversions.h" | |
| 22 | |
| 23 namespace cc { | |
| 24 namespace { | |
| 25 | |
| 26 void ExecuteCalculateDrawProperties(LayerImpl* root, | |
| 27 LayerImplList* render_surface_layer_list) { | |
| 28 // Sanity check: The test itself should create the root layer's render | |
| 29 // surface, so that the surface (and its damage tracker) can | |
| 30 // persist across multiple calls to this function. | |
| 31 ASSERT_TRUE(root->render_surface()); | |
| 32 ASSERT_FALSE(render_surface_layer_list->size()); | |
| 33 | |
| 34 FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root); | |
| 35 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs( | |
| 36 root, root->bounds(), render_surface_layer_list); | |
| 37 LayerTreeHostCommon::CalculateDrawProperties(&inputs); | |
| 38 } | |
| 39 | |
| 40 void ClearDamageForAllSurfaces(LayerImpl* layer) { | |
| 41 if (layer->render_surface()) | |
| 42 layer->render_surface()->damage_tracker()->DidDrawDamagedArea(); | |
| 43 | |
| 44 // Recursively clear damage for any existing surface. | |
| 45 for (size_t i = 0; i < layer->children().size(); ++i) | |
| 46 ClearDamageForAllSurfaces(layer->children()[i]); | |
| 47 } | |
| 48 | |
| 49 void EmulateDrawingOneFrame(LayerImpl* root) { | |
| 50 // This emulates only steps that are relevant to testing the damage tracker: | |
| 51 // 1. computing the render passes and layerlists | |
| 52 // 2. updating all damage trackers in the correct order | |
| 53 // 3. resetting all update_rects and property_changed flags for all layers | |
| 54 // and surfaces. | |
| 55 | |
| 56 LayerImplList render_surface_layer_list; | |
| 57 ExecuteCalculateDrawProperties(root, &render_surface_layer_list); | |
| 58 | |
| 59 // Iterate back-to-front, so that damage correctly propagates from descendant | |
| 60 // surfaces to ancestors. | |
| 61 for (int i = render_surface_layer_list.size() - 1; i >= 0; --i) { | |
| 62 RenderSurfaceImpl* target_surface = | |
| 63 render_surface_layer_list[i]->render_surface(); | |
| 64 target_surface->damage_tracker()->UpdateDamageTrackingState( | |
| 65 target_surface->layer_list(), | |
| 66 target_surface->OwningLayerId(), | |
| 67 target_surface->SurfacePropertyChangedOnlyFromDescendant(), | |
| 68 target_surface->content_rect(), | |
| 69 render_surface_layer_list[i]->mask_layer(), | |
| 70 render_surface_layer_list[i]->filters()); | |
| 71 } | |
| 72 | |
| 73 root->ResetAllChangeTrackingForSubtree(); | |
| 74 } | |
| 75 | |
| 76 class DamageTrackerTest : public testing::Test { | |
| 77 public: | |
| 78 DamageTrackerTest() | |
| 79 : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_) {} | |
| 80 | |
| 81 scoped_ptr<LayerImpl> CreateTestTreeWithOneSurface() { | |
| 82 scoped_ptr<LayerImpl> root = | |
| 83 LayerImpl::Create(host_impl_.active_tree(), 1); | |
| 84 scoped_ptr<LayerImpl> child = | |
| 85 LayerImpl::Create(host_impl_.active_tree(), 2); | |
| 86 | |
| 87 root->SetPosition(gfx::PointF()); | |
| 88 root->SetBounds(gfx::Size(500, 500)); | |
| 89 root->SetContentBounds(gfx::Size(500, 500)); | |
| 90 root->SetDrawsContent(true); | |
| 91 root->SetHasRenderSurface(true); | |
| 92 root->render_surface()->SetContentRect(gfx::Rect(0, 0, 500, 500)); | |
| 93 | |
| 94 child->SetPosition(gfx::PointF(100.f, 100.f)); | |
| 95 child->SetBounds(gfx::Size(30, 30)); | |
| 96 child->SetContentBounds(gfx::Size(30, 30)); | |
| 97 child->SetDrawsContent(true); | |
| 98 root->AddChild(child.Pass()); | |
| 99 | |
| 100 return root.Pass(); | |
| 101 } | |
| 102 | |
| 103 scoped_ptr<LayerImpl> CreateTestTreeWithTwoSurfaces() { | |
| 104 // This test tree has two render surfaces: one for the root, and one for | |
| 105 // child1. Additionally, the root has a second child layer, and child1 has | |
| 106 // two children of its own. | |
| 107 | |
| 108 scoped_ptr<LayerImpl> root = | |
| 109 LayerImpl::Create(host_impl_.active_tree(), 1); | |
| 110 scoped_ptr<LayerImpl> child1 = | |
| 111 LayerImpl::Create(host_impl_.active_tree(), 2); | |
| 112 scoped_ptr<LayerImpl> child2 = | |
| 113 LayerImpl::Create(host_impl_.active_tree(), 3); | |
| 114 scoped_ptr<LayerImpl> grand_child1 = | |
| 115 LayerImpl::Create(host_impl_.active_tree(), 4); | |
| 116 scoped_ptr<LayerImpl> grand_child2 = | |
| 117 LayerImpl::Create(host_impl_.active_tree(), 5); | |
| 118 | |
| 119 root->SetPosition(gfx::PointF()); | |
| 120 root->SetBounds(gfx::Size(500, 500)); | |
| 121 root->SetContentBounds(gfx::Size(500, 500)); | |
| 122 root->SetDrawsContent(true); | |
| 123 root->SetHasRenderSurface(true); | |
| 124 root->render_surface()->SetContentRect(gfx::Rect(0, 0, 500, 500)); | |
| 125 | |
| 126 child1->SetPosition(gfx::PointF(100.f, 100.f)); | |
| 127 child1->SetBounds(gfx::Size(30, 30)); | |
| 128 child1->SetContentBounds(gfx::Size(30, 30)); | |
| 129 // With a child that draws_content, opacity will cause the layer to create | |
| 130 // its own RenderSurface. This layer does not draw, but is intended to | |
| 131 // create its own RenderSurface. | |
| 132 child1->SetDrawsContent(false); | |
| 133 child1->SetHasRenderSurface(true); | |
| 134 | |
| 135 child2->SetPosition(gfx::PointF(11.f, 11.f)); | |
| 136 child2->SetBounds(gfx::Size(18, 18)); | |
| 137 child2->SetContentBounds(gfx::Size(18, 18)); | |
| 138 child2->SetDrawsContent(true); | |
| 139 | |
| 140 grand_child1->SetPosition(gfx::PointF(200.f, 200.f)); | |
| 141 grand_child1->SetBounds(gfx::Size(6, 8)); | |
| 142 grand_child1->SetContentBounds(gfx::Size(6, 8)); | |
| 143 grand_child1->SetDrawsContent(true); | |
| 144 | |
| 145 grand_child2->SetPosition(gfx::PointF(190.f, 190.f)); | |
| 146 grand_child2->SetBounds(gfx::Size(6, 8)); | |
| 147 grand_child2->SetContentBounds(gfx::Size(6, 8)); | |
| 148 grand_child2->SetDrawsContent(true); | |
| 149 | |
| 150 child1->AddChild(grand_child1.Pass()); | |
| 151 child1->AddChild(grand_child2.Pass()); | |
| 152 root->AddChild(child1.Pass()); | |
| 153 root->AddChild(child2.Pass()); | |
| 154 | |
| 155 return root.Pass(); | |
| 156 } | |
| 157 | |
| 158 scoped_ptr<LayerImpl> CreateAndSetUpTestTreeWithOneSurface() { | |
| 159 scoped_ptr<LayerImpl> root = CreateTestTreeWithOneSurface(); | |
| 160 | |
| 161 // Setup includes going past the first frame which always damages | |
| 162 // everything, so that we can actually perform specific tests. | |
| 163 EmulateDrawingOneFrame(root.get()); | |
| 164 | |
| 165 return root.Pass(); | |
| 166 } | |
| 167 | |
| 168 scoped_ptr<LayerImpl> CreateAndSetUpTestTreeWithTwoSurfaces() { | |
| 169 scoped_ptr<LayerImpl> root = CreateTestTreeWithTwoSurfaces(); | |
| 170 | |
| 171 // Setup includes going past the first frame which always damages | |
| 172 // everything, so that we can actually perform specific tests. | |
| 173 EmulateDrawingOneFrame(root.get()); | |
| 174 | |
| 175 return root.Pass(); | |
| 176 } | |
| 177 | |
| 178 protected: | |
| 179 FakeImplProxy proxy_; | |
| 180 TestSharedBitmapManager shared_bitmap_manager_; | |
| 181 TestTaskGraphRunner task_graph_runner_; | |
| 182 FakeLayerTreeHostImpl host_impl_; | |
| 183 }; | |
| 184 | |
| 185 TEST_F(DamageTrackerTest, SanityCheckTestTreeWithOneSurface) { | |
| 186 // Sanity check that the simple test tree will actually produce the expected | |
| 187 // render surfaces and layer lists. | |
| 188 | |
| 189 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 190 | |
| 191 EXPECT_EQ(2u, root->render_surface()->layer_list().size()); | |
| 192 EXPECT_EQ(1, root->render_surface()->layer_list()[0]->id()); | |
| 193 EXPECT_EQ(2, root->render_surface()->layer_list()[1]->id()); | |
| 194 | |
| 195 gfx::Rect root_damage_rect = | |
| 196 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 197 | |
| 198 EXPECT_EQ(gfx::Rect(500, 500).ToString(), root_damage_rect.ToString()); | |
| 199 } | |
| 200 | |
| 201 TEST_F(DamageTrackerTest, SanityCheckTestTreeWithTwoSurfaces) { | |
| 202 // Sanity check that the complex test tree will actually produce the expected | |
| 203 // render surfaces and layer lists. | |
| 204 | |
| 205 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 206 | |
| 207 LayerImpl* child1 = root->children()[0]; | |
| 208 LayerImpl* child2 = root->children()[1]; | |
| 209 gfx::Rect child_damage_rect = | |
| 210 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 211 gfx::Rect root_damage_rect = | |
| 212 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 213 | |
| 214 ASSERT_TRUE(child1->render_surface()); | |
| 215 EXPECT_FALSE(child2->render_surface()); | |
| 216 EXPECT_EQ(3u, root->render_surface()->layer_list().size()); | |
| 217 EXPECT_EQ(2u, child1->render_surface()->layer_list().size()); | |
| 218 | |
| 219 // The render surface for child1 only has a content_rect that encloses | |
| 220 // grand_child1 and grand_child2, because child1 does not draw content. | |
| 221 EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(), | |
| 222 child_damage_rect.ToString()); | |
| 223 EXPECT_EQ(gfx::Rect(500, 500).ToString(), root_damage_rect.ToString()); | |
| 224 } | |
| 225 | |
| 226 TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) { | |
| 227 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 228 LayerImpl* child = root->children()[0]; | |
| 229 | |
| 230 // CASE 1: Setting the update rect should cause the corresponding damage to | |
| 231 // the surface. | |
| 232 ClearDamageForAllSurfaces(root.get()); | |
| 233 child->SetUpdateRect(gfx::Rect(10, 11, 12, 13)); | |
| 234 EmulateDrawingOneFrame(root.get()); | |
| 235 | |
| 236 // Damage position on the surface should be: position of update_rect (10, 11) | |
| 237 // relative to the child (100, 100). | |
| 238 gfx::Rect root_damage_rect = | |
| 239 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 240 EXPECT_EQ(gfx::Rect(110, 111, 12, 13).ToString(), | |
| 241 root_damage_rect.ToString()); | |
| 242 | |
| 243 // CASE 2: The same update rect twice in a row still produces the same | |
| 244 // damage. | |
| 245 ClearDamageForAllSurfaces(root.get()); | |
| 246 child->SetUpdateRect(gfx::Rect(10, 11, 12, 13)); | |
| 247 EmulateDrawingOneFrame(root.get()); | |
| 248 root_damage_rect = | |
| 249 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 250 EXPECT_EQ(gfx::Rect(110, 111, 12, 13).ToString(), | |
| 251 root_damage_rect.ToString()); | |
| 252 | |
| 253 // CASE 3: Setting a different update rect should cause damage on the new | |
| 254 // update region, but no additional exposed old region. | |
| 255 ClearDamageForAllSurfaces(root.get()); | |
| 256 child->SetUpdateRect(gfx::Rect(20, 25, 1, 2)); | |
| 257 EmulateDrawingOneFrame(root.get()); | |
| 258 | |
| 259 // Damage position on the surface should be: position of update_rect (20, 25) | |
| 260 // relative to the child (100, 100). | |
| 261 root_damage_rect = | |
| 262 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 263 EXPECT_EQ(gfx::Rect(120, 125, 1, 2).ToString(), root_damage_rect.ToString()); | |
| 264 } | |
| 265 | |
| 266 TEST_F(DamageTrackerTest, VerifyDamageForLayerDamageRects) { | |
| 267 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 268 LayerImpl* child = root->children()[0]; | |
| 269 | |
| 270 // CASE 1: Adding the layer damage rect should cause the corresponding damage | |
| 271 // to the surface. | |
| 272 ClearDamageForAllSurfaces(root.get()); | |
| 273 child->AddDamageRect(gfx::RectF(10.f, 11.f, 12.f, 13.f)); | |
| 274 EmulateDrawingOneFrame(root.get()); | |
| 275 | |
| 276 // Damage position on the surface should be: position of layer damage_rect | |
| 277 // (10, 11) relative to the child (100, 100). | |
| 278 gfx::Rect root_damage_rect = | |
| 279 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 280 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 12, 13))); | |
| 281 | |
| 282 // CASE 2: The same layer damage rect twice in a row still produces the same | |
| 283 // damage. | |
| 284 ClearDamageForAllSurfaces(root.get()); | |
| 285 child->AddDamageRect(gfx::RectF(10.f, 11.f, 12.f, 13.f)); | |
| 286 EmulateDrawingOneFrame(root.get()); | |
| 287 root_damage_rect = | |
| 288 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 289 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 12, 13))); | |
| 290 | |
| 291 // CASE 3: Adding a different layer damage rect should cause damage on the | |
| 292 // new damaged region, but no additional exposed old region. | |
| 293 ClearDamageForAllSurfaces(root.get()); | |
| 294 child->AddDamageRect(gfx::RectF(20.f, 25.f, 1.f, 2.f)); | |
| 295 EmulateDrawingOneFrame(root.get()); | |
| 296 | |
| 297 // Damage position on the surface should be: position of layer damage_rect | |
| 298 // (20, 25) relative to the child (100, 100). | |
| 299 root_damage_rect = | |
| 300 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 301 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(120, 125, 1, 2))); | |
| 302 | |
| 303 // CASE 4: Adding multiple layer damage rects should cause a unified | |
| 304 // damage on root damage rect. | |
| 305 ClearDamageForAllSurfaces(root.get()); | |
| 306 child->AddDamageRect(gfx::RectF(20.f, 25.f, 1.f, 2.f)); | |
| 307 child->AddDamageRect(gfx::RectF(10.f, 15.f, 3.f, 4.f)); | |
| 308 EmulateDrawingOneFrame(root.get()); | |
| 309 | |
| 310 // Damage position on the surface should be: position of layer damage_rect | |
| 311 // (20, 25) relative to the child (100, 100). | |
| 312 root_damage_rect = | |
| 313 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 314 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(120, 125, 1, 2))); | |
| 315 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 115, 3, 4))); | |
| 316 } | |
| 317 | |
| 318 TEST_F(DamageTrackerTest, VerifyDamageForLayerUpdateAndDamageRects) { | |
| 319 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 320 LayerImpl* child = root->children()[0]; | |
| 321 | |
| 322 // CASE 1: Adding the layer damage rect and update rect should cause the | |
| 323 // corresponding damage to the surface. | |
| 324 ClearDamageForAllSurfaces(root.get()); | |
| 325 child->AddDamageRect(gfx::RectF(5.f, 6.f, 12.f, 13.f)); | |
| 326 child->SetUpdateRect(gfx::Rect(15, 16, 14, 10)); | |
| 327 EmulateDrawingOneFrame(root.get()); | |
| 328 | |
| 329 // Damage position on the surface should be: position of unified layer | |
| 330 // damage_rect and update rect (5, 6) | |
| 331 // relative to the child (100, 100). | |
| 332 gfx::Rect root_damage_rect = | |
| 333 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 334 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(105, 106, 24, 20))); | |
| 335 | |
| 336 // CASE 2: The same layer damage rect and update rect twice in a row still | |
| 337 // produces the same damage. | |
| 338 ClearDamageForAllSurfaces(root.get()); | |
| 339 child->AddDamageRect(gfx::RectF(10.f, 11.f, 12.f, 13.f)); | |
| 340 child->SetUpdateRect(gfx::Rect(10, 11, 14, 15)); | |
| 341 EmulateDrawingOneFrame(root.get()); | |
| 342 root_damage_rect = | |
| 343 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 344 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 14, 15))); | |
| 345 | |
| 346 // CASE 3: Adding a different layer damage rect and update rect should cause | |
| 347 // damage on the new damaged region, but no additional exposed old region. | |
| 348 ClearDamageForAllSurfaces(root.get()); | |
| 349 child->AddDamageRect(gfx::RectF(20.f, 25.f, 2.f, 3.f)); | |
| 350 child->SetUpdateRect(gfx::Rect(5, 10, 7, 8)); | |
| 351 EmulateDrawingOneFrame(root.get()); | |
| 352 | |
| 353 // Damage position on the surface should be: position of unified layer damage | |
| 354 // rect and update rect (5, 10) relative to the child (100, 100). | |
| 355 root_damage_rect = | |
| 356 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 357 EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(105, 110, 17, 18))); | |
| 358 } | |
| 359 | |
| 360 TEST_F(DamageTrackerTest, VerifyDamageForPropertyChanges) { | |
| 361 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 362 LayerImpl* child = root->children()[0]; | |
| 363 | |
| 364 // CASE 1: The layer's property changed flag takes priority over update rect. | |
| 365 // | |
| 366 ClearDamageForAllSurfaces(root.get()); | |
| 367 child->SetUpdateRect(gfx::Rect(10, 11, 12, 13)); | |
| 368 child->SetOpacity(0.5f); | |
| 369 EmulateDrawingOneFrame(root.get()); | |
| 370 | |
| 371 // Sanity check - we should not have accidentally created a separate render | |
| 372 // surface for the translucent layer. | |
| 373 ASSERT_FALSE(child->render_surface()); | |
| 374 ASSERT_EQ(2u, root->render_surface()->layer_list().size()); | |
| 375 | |
| 376 // Damage should be the entire child layer in target_surface space. | |
| 377 gfx::Rect expected_rect = gfx::Rect(100, 100, 30, 30); | |
| 378 gfx::Rect root_damage_rect = | |
| 379 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 380 EXPECT_EQ(expected_rect.ToString(), root_damage_rect.ToString()); | |
| 381 | |
| 382 // CASE 2: If a layer moves due to property change, it damages both the new | |
| 383 // location and the old (exposed) location. The old location is the | |
| 384 // entire old layer, not just the update_rect. | |
| 385 | |
| 386 // Cycle one frame of no change, just to sanity check that the next rect is | |
| 387 // not because of the old damage state. | |
| 388 ClearDamageForAllSurfaces(root.get()); | |
| 389 EmulateDrawingOneFrame(root.get()); | |
| 390 root_damage_rect = | |
| 391 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 392 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 393 | |
| 394 // Then, test the actual layer movement. | |
| 395 ClearDamageForAllSurfaces(root.get()); | |
| 396 child->SetPosition(gfx::PointF(200.f, 230.f)); | |
| 397 EmulateDrawingOneFrame(root.get()); | |
| 398 | |
| 399 // Expect damage to be the combination of the previous one and the new one. | |
| 400 expected_rect.Union(gfx::Rect(200, 230, 30, 30)); | |
| 401 root_damage_rect = | |
| 402 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 403 EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect); | |
| 404 } | |
| 405 | |
| 406 TEST_F(DamageTrackerTest, VerifyDamageForTransformedLayer) { | |
| 407 // If a layer is transformed, the damage rect should still enclose the entire | |
| 408 // transformed layer. | |
| 409 | |
| 410 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 411 LayerImpl* child = root->children()[0]; | |
| 412 | |
| 413 gfx::Transform rotation; | |
| 414 rotation.Rotate(45.0); | |
| 415 | |
| 416 ClearDamageForAllSurfaces(root.get()); | |
| 417 child->SetTransformOrigin(gfx::Point3F( | |
| 418 child->bounds().width() * 0.5f, child->bounds().height() * 0.5f, 0.f)); | |
| 419 child->SetPosition(gfx::PointF(85.f, 85.f)); | |
| 420 EmulateDrawingOneFrame(root.get()); | |
| 421 | |
| 422 // Sanity check that the layer actually moved to (85, 85), damaging its old | |
| 423 // location and new location. | |
| 424 gfx::Rect root_damage_rect = | |
| 425 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 426 EXPECT_EQ(gfx::Rect(85, 85, 45, 45).ToString(), root_damage_rect.ToString()); | |
| 427 | |
| 428 // With the anchor on the layer's center, now we can test the rotation more | |
| 429 // intuitively, since it applies about the layer's anchor. | |
| 430 ClearDamageForAllSurfaces(root.get()); | |
| 431 child->SetTransform(rotation); | |
| 432 EmulateDrawingOneFrame(root.get()); | |
| 433 | |
| 434 // Since the child layer is square, rotation by 45 degrees about the center | |
| 435 // should increase the size of the expected rect by sqrt(2), centered around | |
| 436 // (100, 100). The old exposed region should be fully contained in the new | |
| 437 // region. | |
| 438 float expected_width = 30.f * sqrt(2.f); | |
| 439 float expected_position = 100.f - 0.5f * expected_width; | |
| 440 gfx::Rect expected_rect = gfx::ToEnclosingRect(gfx::RectF( | |
| 441 expected_position, expected_position, expected_width, expected_width)); | |
| 442 root_damage_rect = | |
| 443 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 444 EXPECT_EQ(expected_rect.ToString(), root_damage_rect.ToString()); | |
| 445 } | |
| 446 | |
| 447 TEST_F(DamageTrackerTest, VerifyDamageForPerspectiveClippedLayer) { | |
| 448 // If a layer has a perspective transform that causes w < 0, then not | |
| 449 // clipping the layer can cause an invalid damage rect. This test checks that | |
| 450 // the w < 0 case is tracked properly. | |
| 451 // | |
| 452 // The transform is constructed so that if w < 0 clipping is not performed, | |
| 453 // the incorrect rect will be very small, specifically: position (500.972504, | |
| 454 // 498.544617) and size 0.056610 x 2.910767. Instead, the correctly | |
| 455 // transformed rect should actually be very huge (i.e. in theory, -infinity | |
| 456 // on the left), and positioned so that the right-most bound rect will be | |
| 457 // approximately 501 units in root surface space. | |
| 458 // | |
| 459 | |
| 460 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 461 LayerImpl* child = root->children()[0]; | |
| 462 | |
| 463 gfx::Transform transform; | |
| 464 transform.Translate3d(500.0, 500.0, 0.0); | |
| 465 transform.ApplyPerspectiveDepth(1.0); | |
| 466 transform.RotateAboutYAxis(45.0); | |
| 467 transform.Translate3d(-50.0, -50.0, 0.0); | |
| 468 | |
| 469 // Set up the child | |
| 470 child->SetPosition(gfx::PointF(0.f, 0.f)); | |
| 471 child->SetBounds(gfx::Size(100, 100)); | |
| 472 child->SetContentBounds(gfx::Size(100, 100)); | |
| 473 child->SetTransform(transform); | |
| 474 EmulateDrawingOneFrame(root.get()); | |
| 475 | |
| 476 // Sanity check that the child layer's bounds would actually get clipped by | |
| 477 // w < 0, otherwise this test is not actually testing the intended scenario. | |
| 478 gfx::QuadF test_quad(gfx::RectF(gfx::PointF(), gfx::SizeF(100.f, 100.f))); | |
| 479 bool clipped = false; | |
| 480 MathUtil::MapQuad(transform, test_quad, &clipped); | |
| 481 EXPECT_TRUE(clipped); | |
| 482 | |
| 483 // Damage the child without moving it. | |
| 484 ClearDamageForAllSurfaces(root.get()); | |
| 485 child->SetOpacity(0.5f); | |
| 486 EmulateDrawingOneFrame(root.get()); | |
| 487 | |
| 488 // The expected damage should cover the entire root surface (500x500), but we | |
| 489 // don't care whether the damage rect was clamped or is larger than the | |
| 490 // surface for this test. | |
| 491 gfx::Rect root_damage_rect = | |
| 492 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 493 gfx::Rect damage_we_care_about = gfx::Rect(gfx::Size(500, 500)); | |
| 494 EXPECT_TRUE(root_damage_rect.Contains(damage_we_care_about)); | |
| 495 } | |
| 496 | |
| 497 TEST_F(DamageTrackerTest, VerifyDamageForBlurredSurface) { | |
| 498 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 499 LayerImpl* surface = root->children()[0]; | |
| 500 LayerImpl* child = surface->children()[0]; | |
| 501 | |
| 502 FilterOperations filters; | |
| 503 filters.Append(FilterOperation::CreateBlurFilter(5.f)); | |
| 504 int outset_top, outset_right, outset_bottom, outset_left; | |
| 505 filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left); | |
| 506 | |
| 507 // Setting the filter will damage the whole surface. | |
| 508 ClearDamageForAllSurfaces(root.get()); | |
| 509 surface->SetFilters(filters); | |
| 510 EmulateDrawingOneFrame(root.get()); | |
| 511 | |
| 512 // Setting the update rect should cause the corresponding damage to the | |
| 513 // surface, blurred based on the size of the blur filter. | |
| 514 ClearDamageForAllSurfaces(root.get()); | |
| 515 child->SetUpdateRect(gfx::Rect(1, 2, 3, 4)); | |
| 516 EmulateDrawingOneFrame(root.get()); | |
| 517 | |
| 518 // Damage position on the surface should be: position of update_rect (1, 2) | |
| 519 // relative to the child (300, 300), but expanded by the blur outsets. | |
| 520 gfx::Rect root_damage_rect = | |
| 521 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 522 gfx::Rect expected_damage_rect = gfx::Rect(301, 302, 3, 4); | |
| 523 | |
| 524 expected_damage_rect.Inset(-outset_left, | |
| 525 -outset_top, | |
| 526 -outset_right, | |
| 527 -outset_bottom); | |
| 528 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 529 } | |
| 530 | |
| 531 TEST_F(DamageTrackerTest, VerifyDamageForImageFilter) { | |
| 532 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 533 LayerImpl* child = root->children()[0]; | |
| 534 gfx::Rect root_damage_rect, child_damage_rect; | |
| 535 | |
| 536 // Allow us to set damage on child too. | |
| 537 child->SetDrawsContent(true); | |
| 538 | |
| 539 skia::RefPtr<SkImageFilter> filter = skia::AdoptRef( | |
| 540 SkBlurImageFilter::Create(SkIntToScalar(2), SkIntToScalar(2))); | |
| 541 FilterOperations filters; | |
| 542 filters.Append(FilterOperation::CreateReferenceFilter(filter)); | |
| 543 | |
| 544 // Setting the filter will damage the whole surface. | |
| 545 ClearDamageForAllSurfaces(root.get()); | |
| 546 child->SetHasRenderSurface(true); | |
| 547 child->SetFilters(filters); | |
| 548 EmulateDrawingOneFrame(root.get()); | |
| 549 root_damage_rect = | |
| 550 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 551 child_damage_rect = | |
| 552 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 553 EXPECT_EQ(gfx::Rect(100, 100, 30, 30).ToString(), | |
| 554 root_damage_rect.ToString()); | |
| 555 EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString()); | |
| 556 | |
| 557 // CASE 1: Setting the update rect should damage the whole surface (for now) | |
| 558 ClearDamageForAllSurfaces(root.get()); | |
| 559 child->SetUpdateRect(gfx::Rect(1, 1)); | |
| 560 EmulateDrawingOneFrame(root.get()); | |
| 561 | |
| 562 root_damage_rect = | |
| 563 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 564 child_damage_rect = | |
| 565 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 566 EXPECT_EQ(gfx::Rect(100, 100, 30, 30).ToString(), | |
| 567 root_damage_rect.ToString()); | |
| 568 EXPECT_EQ(gfx::Rect(30.f, 30.f).ToString(), child_damage_rect.ToString()); | |
| 569 } | |
| 570 | |
| 571 TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) { | |
| 572 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 573 LayerImpl* child1 = root->children()[0]; | |
| 574 LayerImpl* child2 = root->children()[1]; | |
| 575 | |
| 576 // Allow us to set damage on child1 too. | |
| 577 child1->SetDrawsContent(true); | |
| 578 | |
| 579 FilterOperations filters; | |
| 580 filters.Append(FilterOperation::CreateBlurFilter(2.f)); | |
| 581 int outset_top, outset_right, outset_bottom, outset_left; | |
| 582 filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left); | |
| 583 | |
| 584 // Setting the filter will damage the whole surface. | |
| 585 ClearDamageForAllSurfaces(root.get()); | |
| 586 child1->SetBackgroundFilters(filters); | |
| 587 EmulateDrawingOneFrame(root.get()); | |
| 588 | |
| 589 // CASE 1: Setting the update rect should cause the corresponding damage to | |
| 590 // the surface, blurred based on the size of the child's background | |
| 591 // blur filter. | |
| 592 ClearDamageForAllSurfaces(root.get()); | |
| 593 root->SetUpdateRect(gfx::Rect(297, 297, 2, 2)); | |
| 594 EmulateDrawingOneFrame(root.get()); | |
| 595 | |
| 596 gfx::Rect root_damage_rect = | |
| 597 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 598 // Damage position on the surface should be a composition of the damage on | |
| 599 // the root and on child2. Damage on the root should be: position of | |
| 600 // update_rect (297, 297), but expanded by the blur outsets. | |
| 601 gfx::Rect expected_damage_rect = gfx::Rect(297, 297, 2, 2); | |
| 602 | |
| 603 expected_damage_rect.Inset(-outset_left, | |
| 604 -outset_top, | |
| 605 -outset_right, | |
| 606 -outset_bottom); | |
| 607 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 608 | |
| 609 // CASE 2: Setting the update rect should cause the corresponding damage to | |
| 610 // the surface, blurred based on the size of the child's background | |
| 611 // blur filter. Since the damage extends to the right/bottom outside | |
| 612 // of the blurred layer, only the left/top should end up expanded. | |
| 613 ClearDamageForAllSurfaces(root.get()); | |
| 614 root->SetUpdateRect(gfx::Rect(297, 297, 30, 30)); | |
| 615 EmulateDrawingOneFrame(root.get()); | |
| 616 | |
| 617 root_damage_rect = | |
| 618 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 619 // Damage position on the surface should be a composition of the damage on | |
| 620 // the root and on child2. Damage on the root should be: position of | |
| 621 // update_rect (297, 297), but expanded on the left/top by the blur outsets. | |
| 622 expected_damage_rect = gfx::Rect(297, 297, 30, 30); | |
| 623 | |
| 624 expected_damage_rect.Inset(-outset_left, | |
| 625 -outset_top, | |
| 626 0, | |
| 627 0); | |
| 628 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 629 | |
| 630 // CASE 3: Setting this update rect outside the blurred content_bounds of the | |
| 631 // blurred child1 will not cause it to be expanded. | |
| 632 ClearDamageForAllSurfaces(root.get()); | |
| 633 root->SetUpdateRect(gfx::Rect(30, 30, 2, 2)); | |
| 634 EmulateDrawingOneFrame(root.get()); | |
| 635 | |
| 636 root_damage_rect = | |
| 637 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 638 // Damage on the root should be: position of update_rect (30, 30), not | |
| 639 // expanded. | |
| 640 expected_damage_rect = gfx::Rect(30, 30, 2, 2); | |
| 641 | |
| 642 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 643 | |
| 644 // CASE 4: Setting this update rect inside the blurred content_bounds but | |
| 645 // outside the original content_bounds of the blurred child1 will | |
| 646 // cause it to be expanded. | |
| 647 ClearDamageForAllSurfaces(root.get()); | |
| 648 root->SetUpdateRect(gfx::Rect(99, 99, 1, 1)); | |
| 649 EmulateDrawingOneFrame(root.get()); | |
| 650 | |
| 651 root_damage_rect = | |
| 652 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 653 // Damage on the root should be: position of update_rect (99, 99), expanded by | |
| 654 // the blurring on child1, but since it is 1 pixel outside the layer, the | |
| 655 // expanding should be reduced by 1. | |
| 656 expected_damage_rect = gfx::Rect(99, 99, 1, 1); | |
| 657 | |
| 658 expected_damage_rect.Inset(-outset_left + 1, | |
| 659 -outset_top + 1, | |
| 660 -outset_right, | |
| 661 -outset_bottom); | |
| 662 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 663 | |
| 664 // CASE 5: Setting the update rect on child2, which is above child1, will | |
| 665 // not get blurred by child1, so it does not need to get expanded. | |
| 666 ClearDamageForAllSurfaces(root.get()); | |
| 667 child2->SetUpdateRect(gfx::Rect(1, 1)); | |
| 668 EmulateDrawingOneFrame(root.get()); | |
| 669 | |
| 670 root_damage_rect = | |
| 671 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 672 // Damage on child2 should be: position of update_rect offset by the child's | |
| 673 // position (11, 11), and not expanded by anything. | |
| 674 expected_damage_rect = gfx::Rect(11, 11, 1, 1); | |
| 675 | |
| 676 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 677 | |
| 678 // CASE 6: Setting the update rect on child1 will also blur the damage, so | |
| 679 // that any pixels needed for the blur are redrawn in the current | |
| 680 // frame. | |
| 681 ClearDamageForAllSurfaces(root.get()); | |
| 682 child1->SetUpdateRect(gfx::Rect(1, 1)); | |
| 683 EmulateDrawingOneFrame(root.get()); | |
| 684 | |
| 685 root_damage_rect = | |
| 686 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 687 // Damage on child1 should be: position of update_rect offset by the child's | |
| 688 // position (100, 100), and expanded by the damage. | |
| 689 expected_damage_rect = gfx::Rect(100, 100, 1, 1); | |
| 690 | |
| 691 expected_damage_rect.Inset(-outset_left, | |
| 692 -outset_top, | |
| 693 -outset_right, | |
| 694 -outset_bottom); | |
| 695 EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString()); | |
| 696 } | |
| 697 | |
| 698 TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingLayer) { | |
| 699 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 700 LayerImpl* child1 = root->children()[0]; | |
| 701 | |
| 702 // CASE 1: Adding a new layer should cause the appropriate damage. | |
| 703 // | |
| 704 ClearDamageForAllSurfaces(root.get()); | |
| 705 { | |
| 706 scoped_ptr<LayerImpl> child2 = | |
| 707 LayerImpl::Create(host_impl_.active_tree(), 3); | |
| 708 child2->SetPosition(gfx::PointF(400.f, 380.f)); | |
| 709 child2->SetBounds(gfx::Size(6, 8)); | |
| 710 child2->SetContentBounds(gfx::Size(6, 8)); | |
| 711 child2->SetDrawsContent(true); | |
| 712 root->AddChild(child2.Pass()); | |
| 713 } | |
| 714 EmulateDrawingOneFrame(root.get()); | |
| 715 | |
| 716 // Sanity check - all 3 layers should be on the same render surface; render | |
| 717 // surfaces are tested elsewhere. | |
| 718 ASSERT_EQ(3u, root->render_surface()->layer_list().size()); | |
| 719 | |
| 720 gfx::Rect root_damage_rect = | |
| 721 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 722 EXPECT_EQ(gfx::Rect(400, 380, 6, 8).ToString(), root_damage_rect.ToString()); | |
| 723 | |
| 724 // CASE 2: If the layer is removed, its entire old layer becomes exposed, not | |
| 725 // just the last update rect. | |
| 726 | |
| 727 // Advance one frame without damage so that we know the damage rect is not | |
| 728 // leftover from the previous case. | |
| 729 ClearDamageForAllSurfaces(root.get()); | |
| 730 EmulateDrawingOneFrame(root.get()); | |
| 731 | |
| 732 root_damage_rect = | |
| 733 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 734 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 735 | |
| 736 // Then, test removing child1. | |
| 737 root->RemoveChild(child1); | |
| 738 child1 = NULL; | |
| 739 EmulateDrawingOneFrame(root.get()); | |
| 740 | |
| 741 root_damage_rect = | |
| 742 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 743 EXPECT_EQ(gfx::Rect(100, 100, 30, 30).ToString(), | |
| 744 root_damage_rect.ToString()); | |
| 745 } | |
| 746 | |
| 747 TEST_F(DamageTrackerTest, VerifyDamageForNewUnchangedLayer) { | |
| 748 // If child2 is added to the layer tree, but it doesn't have any explicit | |
| 749 // damage of its own, it should still indeed damage the target surface. | |
| 750 | |
| 751 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 752 | |
| 753 ClearDamageForAllSurfaces(root.get()); | |
| 754 { | |
| 755 scoped_ptr<LayerImpl> child2 = | |
| 756 LayerImpl::Create(host_impl_.active_tree(), 3); | |
| 757 child2->SetPosition(gfx::PointF(400.f, 380.f)); | |
| 758 child2->SetBounds(gfx::Size(6, 8)); | |
| 759 child2->SetContentBounds(gfx::Size(6, 8)); | |
| 760 child2->SetDrawsContent(true); | |
| 761 child2->ResetAllChangeTrackingForSubtree(); | |
| 762 // Sanity check the initial conditions of the test, if these asserts | |
| 763 // trigger, it means the test no longer actually covers the intended | |
| 764 // scenario. | |
| 765 ASSERT_FALSE(child2->LayerPropertyChanged()); | |
| 766 ASSERT_TRUE(child2->update_rect().IsEmpty()); | |
| 767 root->AddChild(child2.Pass()); | |
| 768 } | |
| 769 EmulateDrawingOneFrame(root.get()); | |
| 770 | |
| 771 // Sanity check - all 3 layers should be on the same render surface; render | |
| 772 // surfaces are tested elsewhere. | |
| 773 ASSERT_EQ(3u, root->render_surface()->layer_list().size()); | |
| 774 | |
| 775 gfx::Rect root_damage_rect = | |
| 776 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 777 EXPECT_EQ(gfx::Rect(400, 380, 6, 8).ToString(), root_damage_rect.ToString()); | |
| 778 } | |
| 779 | |
| 780 TEST_F(DamageTrackerTest, VerifyDamageForMultipleLayers) { | |
| 781 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 782 LayerImpl* child1 = root->children()[0]; | |
| 783 | |
| 784 // In this test we don't want the above tree manipulation to be considered | |
| 785 // part of the same frame. | |
| 786 ClearDamageForAllSurfaces(root.get()); | |
| 787 { | |
| 788 scoped_ptr<LayerImpl> child2 = | |
| 789 LayerImpl::Create(host_impl_.active_tree(), 3); | |
| 790 child2->SetPosition(gfx::PointF(400.f, 380.f)); | |
| 791 child2->SetBounds(gfx::Size(6, 8)); | |
| 792 child2->SetContentBounds(gfx::Size(6, 8)); | |
| 793 child2->SetDrawsContent(true); | |
| 794 root->AddChild(child2.Pass()); | |
| 795 } | |
| 796 LayerImpl* child2 = root->children()[1]; | |
| 797 EmulateDrawingOneFrame(root.get()); | |
| 798 | |
| 799 // Damaging two layers simultaneously should cause combined damage. | |
| 800 // - child1 update rect in surface space: gfx::Rect(100, 100, 1, 2); | |
| 801 // - child2 update rect in surface space: gfx::Rect(400, 380, 3, 4); | |
| 802 ClearDamageForAllSurfaces(root.get()); | |
| 803 child1->SetUpdateRect(gfx::Rect(1, 2)); | |
| 804 child2->SetUpdateRect(gfx::Rect(3, 4)); | |
| 805 EmulateDrawingOneFrame(root.get()); | |
| 806 gfx::Rect root_damage_rect = | |
| 807 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 808 EXPECT_EQ(gfx::Rect(100, 100, 303, 284).ToString(), | |
| 809 root_damage_rect.ToString()); | |
| 810 } | |
| 811 | |
| 812 TEST_F(DamageTrackerTest, VerifyDamageForNestedSurfaces) { | |
| 813 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 814 LayerImpl* child1 = root->children()[0]; | |
| 815 LayerImpl* child2 = root->children()[1]; | |
| 816 LayerImpl* grand_child1 = root->children()[0]->children()[0]; | |
| 817 gfx::Rect child_damage_rect; | |
| 818 gfx::Rect root_damage_rect; | |
| 819 | |
| 820 // CASE 1: Damage to a descendant surface should propagate properly to | |
| 821 // ancestor surface. | |
| 822 ClearDamageForAllSurfaces(root.get()); | |
| 823 grand_child1->SetOpacity(0.5f); | |
| 824 EmulateDrawingOneFrame(root.get()); | |
| 825 child_damage_rect = | |
| 826 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 827 root_damage_rect = | |
| 828 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 829 EXPECT_EQ(gfx::Rect(200, 200, 6, 8).ToString(), child_damage_rect.ToString()); | |
| 830 EXPECT_EQ(gfx::Rect(300, 300, 6, 8).ToString(), root_damage_rect.ToString()); | |
| 831 | |
| 832 // CASE 2: Same as previous case, but with additional damage elsewhere that | |
| 833 // should be properly unioned. | |
| 834 // - child1 surface damage in root surface space: | |
| 835 // gfx::Rect(300, 300, 6, 8); | |
| 836 // - child2 damage in root surface space: | |
| 837 // gfx::Rect(11, 11, 18, 18); | |
| 838 ClearDamageForAllSurfaces(root.get()); | |
| 839 grand_child1->SetOpacity(0.7f); | |
| 840 child2->SetOpacity(0.7f); | |
| 841 EmulateDrawingOneFrame(root.get()); | |
| 842 child_damage_rect = | |
| 843 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 844 root_damage_rect = | |
| 845 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 846 EXPECT_EQ(gfx::Rect(200, 200, 6, 8).ToString(), child_damage_rect.ToString()); | |
| 847 EXPECT_EQ(gfx::Rect(11, 11, 295, 297).ToString(), | |
| 848 root_damage_rect.ToString()); | |
| 849 } | |
| 850 | |
| 851 TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromDescendantLayer) { | |
| 852 // If descendant layer changes and affects the content bounds of the render | |
| 853 // surface, then the entire descendant surface should be damaged, and it | |
| 854 // should damage its ancestor surface with the old and new surface regions. | |
| 855 | |
| 856 // This is a tricky case, since only the first grand_child changes, but the | |
| 857 // entire surface should be marked dirty. | |
| 858 | |
| 859 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 860 LayerImpl* child1 = root->children()[0]; | |
| 861 LayerImpl* grand_child1 = root->children()[0]->children()[0]; | |
| 862 gfx::Rect child_damage_rect; | |
| 863 gfx::Rect root_damage_rect; | |
| 864 | |
| 865 ClearDamageForAllSurfaces(root.get()); | |
| 866 grand_child1->SetPosition(gfx::PointF(195.f, 205.f)); | |
| 867 EmulateDrawingOneFrame(root.get()); | |
| 868 child_damage_rect = | |
| 869 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 870 root_damage_rect = | |
| 871 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 872 | |
| 873 // The new surface bounds should be damaged entirely, even though only one of | |
| 874 // the layers changed. | |
| 875 EXPECT_EQ(gfx::Rect(190, 190, 11, 23).ToString(), | |
| 876 child_damage_rect.ToString()); | |
| 877 | |
| 878 // Damage to the root surface should be the union of child1's *entire* render | |
| 879 // surface (in target space), and its old exposed area (also in target | |
| 880 // space). | |
| 881 EXPECT_EQ(gfx::Rect(290, 290, 16, 23).ToString(), | |
| 882 root_damage_rect.ToString()); | |
| 883 } | |
| 884 | |
| 885 TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) { | |
| 886 // An ancestor/owning layer changes that affects the position/transform of | |
| 887 // the render surface. Note that in this case, the layer_property_changed flag | |
| 888 // already propagates to the subtree (tested in LayerImpltest), which damages | |
| 889 // the entire child1 surface, but the damage tracker still needs the correct | |
| 890 // logic to compute the exposed region on the root surface. | |
| 891 | |
| 892 // TODO(shawnsingh): the expectations of this test case should change when we | |
| 893 // add support for a unique scissor_rect per RenderSurface. In that case, the | |
| 894 // child1 surface should be completely unchanged, since we are only | |
| 895 // transforming it, while the root surface would be damaged appropriately. | |
| 896 | |
| 897 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 898 LayerImpl* child1 = root->children()[0]; | |
| 899 gfx::Rect child_damage_rect; | |
| 900 gfx::Rect root_damage_rect; | |
| 901 | |
| 902 ClearDamageForAllSurfaces(root.get()); | |
| 903 child1->SetPosition(gfx::PointF(50.f, 50.f)); | |
| 904 EmulateDrawingOneFrame(root.get()); | |
| 905 child_damage_rect = | |
| 906 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 907 root_damage_rect = | |
| 908 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 909 | |
| 910 // The new surface bounds should be damaged entirely. | |
| 911 EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(), | |
| 912 child_damage_rect.ToString()); | |
| 913 | |
| 914 // The entire child1 surface and the old exposed child1 surface should damage | |
| 915 // the root surface. | |
| 916 // - old child1 surface in target space: gfx::Rect(290, 290, 16, 18) | |
| 917 // - new child1 surface in target space: gfx::Rect(240, 240, 16, 18) | |
| 918 EXPECT_EQ(gfx::Rect(240, 240, 66, 68).ToString(), | |
| 919 root_damage_rect.ToString()); | |
| 920 } | |
| 921 | |
| 922 TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingRenderSurfaces) { | |
| 923 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 924 LayerImpl* child1 = root->children()[0]; | |
| 925 gfx::Rect child_damage_rect; | |
| 926 gfx::Rect root_damage_rect; | |
| 927 | |
| 928 // CASE 1: If a descendant surface disappears, its entire old area becomes | |
| 929 // exposed. | |
| 930 ClearDamageForAllSurfaces(root.get()); | |
| 931 child1->SetHasRenderSurface(false); | |
| 932 EmulateDrawingOneFrame(root.get()); | |
| 933 | |
| 934 // Sanity check that there is only one surface now. | |
| 935 ASSERT_FALSE(child1->render_surface()); | |
| 936 ASSERT_EQ(4u, root->render_surface()->layer_list().size()); | |
| 937 | |
| 938 root_damage_rect = | |
| 939 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 940 EXPECT_EQ(gfx::Rect(290, 290, 16, 18).ToString(), | |
| 941 root_damage_rect.ToString()); | |
| 942 | |
| 943 // CASE 2: If a descendant surface appears, its entire old area becomes | |
| 944 // exposed. | |
| 945 | |
| 946 // Cycle one frame of no change, just to sanity check that the next rect is | |
| 947 // not because of the old damage state. | |
| 948 ClearDamageForAllSurfaces(root.get()); | |
| 949 EmulateDrawingOneFrame(root.get()); | |
| 950 root_damage_rect = | |
| 951 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 952 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 953 | |
| 954 // Then change the tree so that the render surface is added back. | |
| 955 ClearDamageForAllSurfaces(root.get()); | |
| 956 child1->SetHasRenderSurface(true); | |
| 957 | |
| 958 EmulateDrawingOneFrame(root.get()); | |
| 959 | |
| 960 // Sanity check that there is a new surface now. | |
| 961 ASSERT_TRUE(child1->render_surface()); | |
| 962 EXPECT_EQ(3u, root->render_surface()->layer_list().size()); | |
| 963 EXPECT_EQ(2u, child1->render_surface()->layer_list().size()); | |
| 964 | |
| 965 child_damage_rect = | |
| 966 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 967 root_damage_rect = | |
| 968 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 969 EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(), | |
| 970 child_damage_rect.ToString()); | |
| 971 EXPECT_EQ(gfx::Rect(290, 290, 16, 18).ToString(), | |
| 972 root_damage_rect.ToString()); | |
| 973 } | |
| 974 | |
| 975 TEST_F(DamageTrackerTest, VerifyNoDamageWhenNothingChanged) { | |
| 976 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 977 LayerImpl* child1 = root->children()[0]; | |
| 978 gfx::Rect child_damage_rect; | |
| 979 gfx::Rect root_damage_rect; | |
| 980 | |
| 981 // CASE 1: If nothing changes, the damage rect should be empty. | |
| 982 // | |
| 983 ClearDamageForAllSurfaces(root.get()); | |
| 984 EmulateDrawingOneFrame(root.get()); | |
| 985 child_damage_rect = | |
| 986 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 987 root_damage_rect = | |
| 988 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 989 EXPECT_TRUE(child_damage_rect.IsEmpty()); | |
| 990 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 991 | |
| 992 // CASE 2: If nothing changes twice in a row, the damage rect should still be | |
| 993 // empty. | |
| 994 // | |
| 995 ClearDamageForAllSurfaces(root.get()); | |
| 996 EmulateDrawingOneFrame(root.get()); | |
| 997 child_damage_rect = | |
| 998 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 999 root_damage_rect = | |
| 1000 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1001 EXPECT_TRUE(child_damage_rect.IsEmpty()); | |
| 1002 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 1003 } | |
| 1004 | |
| 1005 TEST_F(DamageTrackerTest, VerifyNoDamageForUpdateRectThatDoesNotDrawContent) { | |
| 1006 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 1007 LayerImpl* child1 = root->children()[0]; | |
| 1008 gfx::Rect child_damage_rect; | |
| 1009 gfx::Rect root_damage_rect; | |
| 1010 | |
| 1011 // In our specific tree, the update rect of child1 should not cause any | |
| 1012 // damage to any surface because it does not actually draw content. | |
| 1013 ClearDamageForAllSurfaces(root.get()); | |
| 1014 child1->SetUpdateRect(gfx::Rect(1, 2)); | |
| 1015 EmulateDrawingOneFrame(root.get()); | |
| 1016 child_damage_rect = | |
| 1017 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1018 root_damage_rect = | |
| 1019 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1020 EXPECT_TRUE(child_damage_rect.IsEmpty()); | |
| 1021 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 1022 } | |
| 1023 | |
| 1024 TEST_F(DamageTrackerTest, VerifyDamageForReplica) { | |
| 1025 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 1026 LayerImpl* child1 = root->children()[0]; | |
| 1027 LayerImpl* grand_child1 = child1->children()[0]; | |
| 1028 LayerImpl* grand_child2 = child1->children()[1]; | |
| 1029 | |
| 1030 // Damage on a surface that has a reflection should cause the target surface | |
| 1031 // to receive the surface's damage and the surface's reflected damage. | |
| 1032 | |
| 1033 // For this test case, we modify grand_child2, and add grand_child3 to extend | |
| 1034 // the bounds of child1's surface. This way, we can test reflection changes | |
| 1035 // without changing content_bounds of the surface. | |
| 1036 grand_child2->SetPosition(gfx::PointF(180.f, 180.f)); | |
| 1037 { | |
| 1038 scoped_ptr<LayerImpl> grand_child3 = | |
| 1039 LayerImpl::Create(host_impl_.active_tree(), 6); | |
| 1040 grand_child3->SetPosition(gfx::PointF(240.f, 240.f)); | |
| 1041 grand_child3->SetBounds(gfx::Size(10, 10)); | |
| 1042 grand_child3->SetContentBounds(gfx::Size(10, 10)); | |
| 1043 grand_child3->SetDrawsContent(true); | |
| 1044 child1->AddChild(grand_child3.Pass()); | |
| 1045 } | |
| 1046 child1->SetOpacity(0.5f); | |
| 1047 EmulateDrawingOneFrame(root.get()); | |
| 1048 | |
| 1049 // CASE 1: adding a reflection about the left edge of grand_child1. | |
| 1050 // | |
| 1051 ClearDamageForAllSurfaces(root.get()); | |
| 1052 { | |
| 1053 scoped_ptr<LayerImpl> grand_child1_replica = | |
| 1054 LayerImpl::Create(host_impl_.active_tree(), 7); | |
| 1055 grand_child1_replica->SetPosition(gfx::PointF()); | |
| 1056 gfx::Transform reflection; | |
| 1057 reflection.Scale3d(-1.0, 1.0, 1.0); | |
| 1058 grand_child1_replica->SetTransform(reflection); | |
| 1059 grand_child1->SetReplicaLayer(grand_child1_replica.Pass()); | |
| 1060 grand_child1->SetHasRenderSurface(true); | |
| 1061 } | |
| 1062 EmulateDrawingOneFrame(root.get()); | |
| 1063 | |
| 1064 gfx::Rect grand_child_damage_rect = | |
| 1065 grand_child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1066 gfx::Rect child_damage_rect = | |
| 1067 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1068 gfx::Rect root_damage_rect = | |
| 1069 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1070 | |
| 1071 // The grand_child surface damage should not include its own replica. The | |
| 1072 // child surface damage should include the normal and replica surfaces. | |
| 1073 EXPECT_EQ(gfx::Rect(6, 8).ToString(), grand_child_damage_rect.ToString()); | |
| 1074 EXPECT_EQ(gfx::Rect(194, 200, 12, 8).ToString(), | |
| 1075 child_damage_rect.ToString()); | |
| 1076 EXPECT_EQ(gfx::Rect(294, 300, 12, 8).ToString(), root_damage_rect.ToString()); | |
| 1077 | |
| 1078 // CASE 2: moving the descendant surface should cause both the original and | |
| 1079 // reflected areas to be damaged on the target. | |
| 1080 ClearDamageForAllSurfaces(root.get()); | |
| 1081 gfx::Rect old_content_rect = child1->render_surface()->content_rect(); | |
| 1082 grand_child1->SetPosition(gfx::PointF(195.f, 205.f)); | |
| 1083 EmulateDrawingOneFrame(root.get()); | |
| 1084 ASSERT_EQ(old_content_rect.width(), | |
| 1085 child1->render_surface()->content_rect().width()); | |
| 1086 ASSERT_EQ(old_content_rect.height(), | |
| 1087 child1->render_surface()->content_rect().height()); | |
| 1088 | |
| 1089 grand_child_damage_rect = | |
| 1090 grand_child1->render_surface()-> | |
| 1091 damage_tracker()->current_damage_rect(); | |
| 1092 child_damage_rect = | |
| 1093 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1094 root_damage_rect = | |
| 1095 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1096 | |
| 1097 // The child surface damage should include normal and replica surfaces for | |
| 1098 // both old and new locations. | |
| 1099 // - old location in target space: gfx::Rect(194, 200, 12, 8) | |
| 1100 // - new location in target space: gfx::Rect(189, 205, 12, 8) | |
| 1101 EXPECT_EQ(gfx::Rect(6, 8).ToString(), grand_child_damage_rect.ToString()); | |
| 1102 EXPECT_EQ(gfx::Rect(189, 200, 17, 13).ToString(), | |
| 1103 child_damage_rect.ToString()); | |
| 1104 EXPECT_EQ(gfx::Rect(289, 300, 17, 13).ToString(), | |
| 1105 root_damage_rect.ToString()); | |
| 1106 | |
| 1107 // CASE 3: removing the reflection should cause the entire region including | |
| 1108 // reflection to damage the target surface. | |
| 1109 ClearDamageForAllSurfaces(root.get()); | |
| 1110 grand_child1->SetReplicaLayer(nullptr); | |
| 1111 grand_child1->SetHasRenderSurface(false); | |
| 1112 EmulateDrawingOneFrame(root.get()); | |
| 1113 ASSERT_EQ(old_content_rect.width(), | |
| 1114 child1->render_surface()->content_rect().width()); | |
| 1115 ASSERT_EQ(old_content_rect.height(), | |
| 1116 child1->render_surface()->content_rect().height()); | |
| 1117 | |
| 1118 EXPECT_FALSE(grand_child1->render_surface()); | |
| 1119 child_damage_rect = | |
| 1120 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1121 root_damage_rect = | |
| 1122 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1123 | |
| 1124 EXPECT_EQ(gfx::Rect(189, 205, 12, 8).ToString(), | |
| 1125 child_damage_rect.ToString()); | |
| 1126 EXPECT_EQ(gfx::Rect(289, 305, 12, 8).ToString(), root_damage_rect.ToString()); | |
| 1127 } | |
| 1128 | |
| 1129 TEST_F(DamageTrackerTest, VerifyDamageForMask) { | |
| 1130 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 1131 LayerImpl* child = root->children()[0]; | |
| 1132 | |
| 1133 // In the current implementation of the damage tracker, changes to mask | |
| 1134 // layers should damage the entire corresponding surface. | |
| 1135 | |
| 1136 ClearDamageForAllSurfaces(root.get()); | |
| 1137 | |
| 1138 // Set up the mask layer. | |
| 1139 { | |
| 1140 scoped_ptr<LayerImpl> mask_layer = | |
| 1141 LayerImpl::Create(host_impl_.active_tree(), 3); | |
| 1142 mask_layer->SetPosition(child->position()); | |
| 1143 mask_layer->SetBounds(child->bounds()); | |
| 1144 mask_layer->SetContentBounds(child->bounds()); | |
| 1145 child->SetMaskLayer(mask_layer.Pass()); | |
| 1146 child->SetHasRenderSurface(true); | |
| 1147 } | |
| 1148 LayerImpl* mask_layer = child->mask_layer(); | |
| 1149 | |
| 1150 // Add opacity and a grand_child so that the render surface persists even | |
| 1151 // after we remove the mask. | |
| 1152 { | |
| 1153 scoped_ptr<LayerImpl> grand_child = | |
| 1154 LayerImpl::Create(host_impl_.active_tree(), 4); | |
| 1155 grand_child->SetPosition(gfx::PointF(2.f, 2.f)); | |
| 1156 grand_child->SetBounds(gfx::Size(2, 2)); | |
| 1157 grand_child->SetContentBounds(gfx::Size(2, 2)); | |
| 1158 grand_child->SetDrawsContent(true); | |
| 1159 child->AddChild(grand_child.Pass()); | |
| 1160 } | |
| 1161 EmulateDrawingOneFrame(root.get()); | |
| 1162 | |
| 1163 // CASE 1: the update_rect on a mask layer should damage the entire target | |
| 1164 // surface. | |
| 1165 ClearDamageForAllSurfaces(root.get()); | |
| 1166 mask_layer->SetUpdateRect(gfx::Rect(1, 2, 3, 4)); | |
| 1167 EmulateDrawingOneFrame(root.get()); | |
| 1168 gfx::Rect child_damage_rect = | |
| 1169 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1170 EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString()); | |
| 1171 | |
| 1172 // CASE 2: a property change on the mask layer should damage the entire | |
| 1173 // target surface. | |
| 1174 | |
| 1175 // Advance one frame without damage so that we know the damage rect is not | |
| 1176 // leftover from the previous case. | |
| 1177 ClearDamageForAllSurfaces(root.get()); | |
| 1178 EmulateDrawingOneFrame(root.get()); | |
| 1179 child_damage_rect = | |
| 1180 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1181 EXPECT_TRUE(child_damage_rect.IsEmpty()); | |
| 1182 | |
| 1183 // Then test the property change. | |
| 1184 ClearDamageForAllSurfaces(root.get()); | |
| 1185 mask_layer->SetStackingOrderChanged(true); | |
| 1186 | |
| 1187 EmulateDrawingOneFrame(root.get()); | |
| 1188 child_damage_rect = | |
| 1189 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1190 EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString()); | |
| 1191 | |
| 1192 // CASE 3: removing the mask also damages the entire target surface. | |
| 1193 // | |
| 1194 | |
| 1195 // Advance one frame without damage so that we know the damage rect is not | |
| 1196 // leftover from the previous case. | |
| 1197 ClearDamageForAllSurfaces(root.get()); | |
| 1198 EmulateDrawingOneFrame(root.get()); | |
| 1199 child_damage_rect = | |
| 1200 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1201 EXPECT_TRUE(child_damage_rect.IsEmpty()); | |
| 1202 | |
| 1203 // Then test mask removal. | |
| 1204 ClearDamageForAllSurfaces(root.get()); | |
| 1205 child->SetMaskLayer(nullptr); | |
| 1206 ASSERT_TRUE(child->LayerPropertyChanged()); | |
| 1207 EmulateDrawingOneFrame(root.get()); | |
| 1208 | |
| 1209 // Sanity check that a render surface still exists. | |
| 1210 ASSERT_TRUE(child->render_surface()); | |
| 1211 | |
| 1212 child_damage_rect = | |
| 1213 child->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1214 EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString()); | |
| 1215 } | |
| 1216 | |
| 1217 TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) { | |
| 1218 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 1219 LayerImpl* child1 = root->children()[0]; | |
| 1220 LayerImpl* grand_child1 = child1->children()[0]; | |
| 1221 | |
| 1222 // Changes to a replica's mask should not damage the original surface, | |
| 1223 // because it is not masked. But it does damage the ancestor target surface. | |
| 1224 | |
| 1225 ClearDamageForAllSurfaces(root.get()); | |
| 1226 | |
| 1227 // Create a reflection about the left edge of grand_child1. | |
| 1228 { | |
| 1229 scoped_ptr<LayerImpl> grand_child1_replica = | |
| 1230 LayerImpl::Create(host_impl_.active_tree(), 6); | |
| 1231 grand_child1_replica->SetPosition(gfx::PointF()); | |
| 1232 gfx::Transform reflection; | |
| 1233 reflection.Scale3d(-1.0, 1.0, 1.0); | |
| 1234 grand_child1_replica->SetTransform(reflection); | |
| 1235 grand_child1->SetReplicaLayer(grand_child1_replica.Pass()); | |
| 1236 grand_child1->SetHasRenderSurface(true); | |
| 1237 } | |
| 1238 LayerImpl* grand_child1_replica = grand_child1->replica_layer(); | |
| 1239 | |
| 1240 // Set up the mask layer on the replica layer | |
| 1241 { | |
| 1242 scoped_ptr<LayerImpl> replica_mask_layer = | |
| 1243 LayerImpl::Create(host_impl_.active_tree(), 7); | |
| 1244 replica_mask_layer->SetPosition(gfx::PointF()); | |
| 1245 replica_mask_layer->SetBounds(grand_child1->bounds()); | |
| 1246 replica_mask_layer->SetContentBounds(grand_child1->bounds()); | |
| 1247 grand_child1_replica->SetMaskLayer(replica_mask_layer.Pass()); | |
| 1248 } | |
| 1249 LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer(); | |
| 1250 | |
| 1251 EmulateDrawingOneFrame(root.get()); | |
| 1252 | |
| 1253 // Sanity check that the appropriate render surfaces were created | |
| 1254 ASSERT_TRUE(grand_child1->render_surface()); | |
| 1255 | |
| 1256 // CASE 1: a property change on the mask should damage only the reflected | |
| 1257 // region on the target surface. | |
| 1258 ClearDamageForAllSurfaces(root.get()); | |
| 1259 replica_mask_layer->SetStackingOrderChanged(true); | |
| 1260 EmulateDrawingOneFrame(root.get()); | |
| 1261 | |
| 1262 gfx::Rect grand_child_damage_rect = | |
| 1263 grand_child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1264 gfx::Rect child_damage_rect = | |
| 1265 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1266 | |
| 1267 EXPECT_TRUE(grand_child_damage_rect.IsEmpty()); | |
| 1268 EXPECT_EQ(gfx::Rect(194, 200, 6, 8).ToString(), child_damage_rect.ToString()); | |
| 1269 | |
| 1270 // CASE 2: removing the replica mask damages only the reflected region on the | |
| 1271 // target surface. | |
| 1272 // | |
| 1273 ClearDamageForAllSurfaces(root.get()); | |
| 1274 grand_child1_replica->SetMaskLayer(nullptr); | |
| 1275 EmulateDrawingOneFrame(root.get()); | |
| 1276 | |
| 1277 grand_child_damage_rect = | |
| 1278 grand_child1->render_surface()->damage_tracker()-> | |
| 1279 current_damage_rect(); | |
| 1280 child_damage_rect = | |
| 1281 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1282 | |
| 1283 EXPECT_TRUE(grand_child_damage_rect.IsEmpty()); | |
| 1284 EXPECT_EQ(gfx::Rect(194, 200, 6, 8).ToString(), child_damage_rect.ToString()); | |
| 1285 } | |
| 1286 | |
| 1287 TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithTransformOrigin) { | |
| 1288 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces(); | |
| 1289 LayerImpl* child1 = root->children()[0]; | |
| 1290 LayerImpl* grand_child1 = child1->children()[0]; | |
| 1291 | |
| 1292 // Verify that the correct replica_origin_transform is used for the | |
| 1293 // replica_mask. | |
| 1294 ClearDamageForAllSurfaces(root.get()); | |
| 1295 | |
| 1296 // This is not actually the transform origin point being tested, but by | |
| 1297 // convention its | |
| 1298 // expected to be the same as the replica's anchor point. | |
| 1299 grand_child1->SetTransformOrigin( | |
| 1300 gfx::Point3F(grand_child1->bounds().width(), 0.f, 0.f)); | |
| 1301 | |
| 1302 { | |
| 1303 scoped_ptr<LayerImpl> grand_child1_replica = | |
| 1304 LayerImpl::Create(host_impl_.active_tree(), 6); | |
| 1305 grand_child1_replica->SetPosition(gfx::PointF()); | |
| 1306 | |
| 1307 // This is the anchor being tested. | |
| 1308 grand_child1_replica->SetTransformOrigin( | |
| 1309 gfx::Point3F(grand_child1->bounds().width(), 0.f, 0.f)); | |
| 1310 gfx::Transform reflection; | |
| 1311 reflection.Scale3d(-1.0, 1.0, 1.0); | |
| 1312 grand_child1_replica->SetTransform(reflection); | |
| 1313 grand_child1->SetReplicaLayer(grand_child1_replica.Pass()); | |
| 1314 grand_child1->SetHasRenderSurface(true); | |
| 1315 } | |
| 1316 LayerImpl* grand_child1_replica = grand_child1->replica_layer(); | |
| 1317 | |
| 1318 // Set up the mask layer on the replica layer | |
| 1319 { | |
| 1320 scoped_ptr<LayerImpl> replica_mask_layer = | |
| 1321 LayerImpl::Create(host_impl_.active_tree(), 7); | |
| 1322 replica_mask_layer->SetPosition(gfx::PointF()); | |
| 1323 // Note: this is not the transform origin being tested. | |
| 1324 replica_mask_layer->SetBounds(grand_child1->bounds()); | |
| 1325 replica_mask_layer->SetContentBounds(grand_child1->bounds()); | |
| 1326 grand_child1_replica->SetMaskLayer(replica_mask_layer.Pass()); | |
| 1327 } | |
| 1328 LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer(); | |
| 1329 | |
| 1330 EmulateDrawingOneFrame(root.get()); | |
| 1331 | |
| 1332 // Sanity check that the appropriate render surfaces were created | |
| 1333 ASSERT_TRUE(grand_child1->render_surface()); | |
| 1334 | |
| 1335 // A property change on the replica_mask should damage the reflected region on | |
| 1336 // the target surface. | |
| 1337 ClearDamageForAllSurfaces(root.get()); | |
| 1338 replica_mask_layer->SetStackingOrderChanged(true); | |
| 1339 | |
| 1340 EmulateDrawingOneFrame(root.get()); | |
| 1341 | |
| 1342 gfx::Rect child_damage_rect = | |
| 1343 child1->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1344 EXPECT_EQ(gfx::Rect(206, 200, 6, 8).ToString(), child_damage_rect.ToString()); | |
| 1345 } | |
| 1346 | |
| 1347 TEST_F(DamageTrackerTest, DamageWhenAddedExternally) { | |
| 1348 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 1349 LayerImpl* child = root->children()[0]; | |
| 1350 | |
| 1351 // Case 1: This test ensures that when the tracker is given damage, that | |
| 1352 // it is included with any other partial damage. | |
| 1353 // | |
| 1354 ClearDamageForAllSurfaces(root.get()); | |
| 1355 child->SetUpdateRect(gfx::Rect(10, 11, 12, 13)); | |
| 1356 root->render_surface()->damage_tracker()->AddDamageNextUpdate( | |
| 1357 gfx::Rect(15, 16, 32, 33)); | |
| 1358 EmulateDrawingOneFrame(root.get()); | |
| 1359 gfx::Rect root_damage_rect = | |
| 1360 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1361 EXPECT_EQ(gfx::UnionRects(gfx::Rect(15, 16, 32, 33), | |
| 1362 gfx::Rect(100 + 10, 100 + 11, 12, 13)).ToString(), | |
| 1363 root_damage_rect.ToString()); | |
| 1364 | |
| 1365 // Case 2: An additional sanity check that adding damage works even when | |
| 1366 // nothing on the layer tree changed. | |
| 1367 // | |
| 1368 ClearDamageForAllSurfaces(root.get()); | |
| 1369 root->render_surface()->damage_tracker()->AddDamageNextUpdate( | |
| 1370 gfx::Rect(30, 31, 14, 15)); | |
| 1371 EmulateDrawingOneFrame(root.get()); | |
| 1372 root_damage_rect = | |
| 1373 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1374 EXPECT_EQ(gfx::Rect(30, 31, 14, 15).ToString(), root_damage_rect.ToString()); | |
| 1375 } | |
| 1376 | |
| 1377 TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) { | |
| 1378 // Though it should never happen, its a good idea to verify that the damage | |
| 1379 // tracker does not crash when it receives an empty layer_list. | |
| 1380 | |
| 1381 scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.active_tree(), 1); | |
| 1382 root->SetHasRenderSurface(true); | |
| 1383 root->draw_properties().render_target = root.get(); | |
| 1384 | |
| 1385 ASSERT_TRUE(root == root->render_target()); | |
| 1386 RenderSurfaceImpl* target_surface = root->render_surface(); | |
| 1387 | |
| 1388 LayerImplList empty_list; | |
| 1389 target_surface->damage_tracker()->UpdateDamageTrackingState( | |
| 1390 empty_list, | |
| 1391 target_surface->OwningLayerId(), | |
| 1392 false, | |
| 1393 gfx::Rect(), | |
| 1394 NULL, | |
| 1395 FilterOperations()); | |
| 1396 | |
| 1397 gfx::Rect damage_rect = | |
| 1398 target_surface->damage_tracker()->current_damage_rect(); | |
| 1399 EXPECT_TRUE(damage_rect.IsEmpty()); | |
| 1400 } | |
| 1401 | |
| 1402 TEST_F(DamageTrackerTest, VerifyDamageAccumulatesUntilReset) { | |
| 1403 // If damage is not cleared, it should accumulate. | |
| 1404 | |
| 1405 scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface(); | |
| 1406 LayerImpl* child = root->children()[0]; | |
| 1407 | |
| 1408 ClearDamageForAllSurfaces(root.get()); | |
| 1409 child->SetUpdateRect(gfx::Rect(10.f, 11.f, 1.f, 2.f)); | |
| 1410 EmulateDrawingOneFrame(root.get()); | |
| 1411 | |
| 1412 // Sanity check damage after the first frame; this isnt the actual test yet. | |
| 1413 gfx::Rect root_damage_rect = | |
| 1414 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1415 EXPECT_EQ(gfx::Rect(110, 111, 1, 2).ToString(), root_damage_rect.ToString()); | |
| 1416 | |
| 1417 // New damage, without having cleared the previous damage, should be unioned | |
| 1418 // to the previous one. | |
| 1419 child->SetUpdateRect(gfx::Rect(20, 25, 1, 2)); | |
| 1420 EmulateDrawingOneFrame(root.get()); | |
| 1421 root_damage_rect = | |
| 1422 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1423 EXPECT_EQ(gfx::Rect(110, 111, 11, 16).ToString(), | |
| 1424 root_damage_rect.ToString()); | |
| 1425 | |
| 1426 // If we notify the damage tracker that we drew the damaged area, then damage | |
| 1427 // should be emptied. | |
| 1428 root->render_surface()->damage_tracker()->DidDrawDamagedArea(); | |
| 1429 root_damage_rect = | |
| 1430 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1431 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 1432 | |
| 1433 // Damage should remain empty even after one frame, since there's yet no new | |
| 1434 // damage. | |
| 1435 EmulateDrawingOneFrame(root.get()); | |
| 1436 root_damage_rect = | |
| 1437 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1438 EXPECT_TRUE(root_damage_rect.IsEmpty()); | |
| 1439 } | |
| 1440 | |
| 1441 TEST_F(DamageTrackerTest, HugeDamageRect) { | |
| 1442 // This number is so large that we start losting floating point accuracy. | |
| 1443 const int kBigNumber = 900000000; | |
| 1444 // Walk over a range to find floating point inaccuracy boundaries that move | |
| 1445 // toward the wrong direction. | |
| 1446 const int kRange = 5000; | |
| 1447 | |
| 1448 for (int i = 0; i < kRange; ++i) { | |
| 1449 scoped_ptr<LayerImpl> root = CreateTestTreeWithOneSurface(); | |
| 1450 LayerImpl* child = root->children()[0]; | |
| 1451 | |
| 1452 gfx::Transform transform; | |
| 1453 transform.Translate(-kBigNumber, -kBigNumber); | |
| 1454 | |
| 1455 // The child layer covers (0, 0, i, i) of the viewport, | |
| 1456 // but has a huge negative position. | |
| 1457 child->SetPosition(gfx::PointF()); | |
| 1458 child->SetBounds(gfx::Size(kBigNumber + i, kBigNumber + i)); | |
| 1459 child->SetContentBounds(gfx::Size(kBigNumber + i, kBigNumber + i)); | |
| 1460 child->SetTransform(transform); | |
| 1461 EmulateDrawingOneFrame(root.get()); | |
| 1462 | |
| 1463 // The expected damage should cover the visible part of the child layer, | |
| 1464 // which is (0, 0, i, i) in the viewport. | |
| 1465 gfx::Rect root_damage_rect = | |
| 1466 root->render_surface()->damage_tracker()->current_damage_rect(); | |
| 1467 gfx::Rect damage_we_care_about = gfx::Rect(i, i); | |
| 1468 EXPECT_LE(damage_we_care_about.right(), root_damage_rect.right()); | |
| 1469 EXPECT_LE(damage_we_care_about.bottom(), root_damage_rect.bottom()); | |
| 1470 } | |
| 1471 } | |
| 1472 | |
| 1473 } // namespace | |
| 1474 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master