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/layers/tiled_layer.h" 6 7 #include <limits> 8 #include <vector> 9 10 #include "base/run_loop.h" 11 #include "cc/resources/bitmap_content_layer_updater.h" 12 #include "cc/resources/layer_painter.h" 13 #include "cc/resources/prioritized_resource_manager.h" 14 #include "cc/resources/resource_update_controller.h" 15 #include "cc/test/animation_test_common.h" 16 #include "cc/test/fake_layer_tree_host_client.h" 17 #include "cc/test/fake_layer_tree_host_impl.h" 18 #include "cc/test/fake_output_surface.h" 19 #include "cc/test/fake_output_surface_client.h" 20 #include "cc/test/fake_proxy.h" 21 #include "cc/test/fake_rendering_stats_instrumentation.h" 22 #include "cc/test/geometry_test_utils.h" 23 #include "cc/test/test_shared_bitmap_manager.h" 24 #include "cc/test/tiled_layer_test_common.h" 25 #include "cc/trees/occlusion_tracker.h" 26 #include "cc/trees/single_thread_proxy.h" 27 #include "testing/gtest/include/gtest/gtest.h" 28 #include "ui/gfx/rect_conversions.h" 29 #include "ui/gfx/transform.h" 30 31 namespace cc { 32 namespace { 33 34 class TestOcclusionTracker : public OcclusionTracker<Layer> { 35 public: 36 TestOcclusionTracker() : OcclusionTracker(gfx::Rect(0, 0, 1000, 1000)) { 37 stack_.push_back(StackObject()); 38 } 39 40 void SetRenderTarget(Layer* render_target) { 41 stack_.back().target = render_target; 42 } 43 44 void SetOcclusion(const SimpleEnclosedRegion& occlusion) { 45 stack_.back().occlusion_from_inside_target = occlusion; 46 } 47 }; 48 49 class SynchronousOutputSurfaceLayerTreeHost : public LayerTreeHost { 50 public: 51 static scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> Create( 52 LayerTreeHostClient* client, 53 SharedBitmapManager* manager, 54 const LayerTreeSettings& settings, 55 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) { 56 return make_scoped_ptr(new SynchronousOutputSurfaceLayerTreeHost( 57 client, manager, settings, impl_task_runner)); 58 } 59 60 virtual ~SynchronousOutputSurfaceLayerTreeHost() {} 61 62 bool EnsureOutputSurfaceCreated() { 63 base::MessageLoop::current()->PostDelayedTask( 64 FROM_HERE, 65 run_loop_.QuitClosure(), 66 base::TimeDelta::FromSeconds(5)); 67 run_loop_.Run(); 68 return output_surface_created_; 69 } 70 71 virtual void OnCreateAndInitializeOutputSurfaceAttempted( 72 bool success) OVERRIDE { 73 LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted(success); 74 output_surface_created_ = success; 75 run_loop_.Quit(); 76 } 77 78 private: 79 SynchronousOutputSurfaceLayerTreeHost( 80 LayerTreeHostClient* client, 81 SharedBitmapManager* manager, 82 const LayerTreeSettings& settings, 83 scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) 84 : LayerTreeHost(client, manager, settings), 85 output_surface_created_(false) { 86 LayerTreeHost::InitializeThreaded(base::MessageLoopProxy::current(), 87 impl_task_runner); 88 } 89 90 bool output_surface_created_; 91 base::RunLoop run_loop_; 92 }; 93 94 class TiledLayerTest : public testing::Test { 95 public: 96 TiledLayerTest() 97 : proxy_(NULL), 98 output_surface_(FakeOutputSurface::Create3d()), 99 queue_(make_scoped_ptr(new ResourceUpdateQueue)), 100 impl_thread_("ImplThread"), 101 fake_layer_tree_host_client_(FakeLayerTreeHostClient::DIRECT_3D), 102 occlusion_(NULL) { 103 settings_.max_partial_texture_updates = std::numeric_limits<size_t>::max(); 104 settings_.layer_transforms_should_scale_layer_contents = true; 105 } 106 107 virtual void SetUp() { 108 impl_thread_.Start(); 109 shared_bitmap_manager_.reset(new TestSharedBitmapManager()); 110 layer_tree_host_ = SynchronousOutputSurfaceLayerTreeHost::Create( 111 &fake_layer_tree_host_client_, 112 shared_bitmap_manager_.get(), 113 settings_, 114 impl_thread_.message_loop_proxy()); 115 fake_layer_tree_host_client_.SetLayerTreeHost(layer_tree_host_.get()); 116 proxy_ = layer_tree_host_->proxy(); 117 resource_manager_ = PrioritizedResourceManager::Create(proxy_); 118 layer_tree_host_->SetLayerTreeHostClientReady(); 119 CHECK(layer_tree_host_->EnsureOutputSurfaceCreated()); 120 layer_tree_host_->SetRootLayer(Layer::Create()); 121 122 CHECK(output_surface_->BindToClient(&output_surface_client_)); 123 124 DebugScopedSetImplThreadAndMainThreadBlocked 125 impl_thread_and_main_thread_blocked(proxy_); 126 resource_provider_ = ResourceProvider::Create(output_surface_.get(), 127 shared_bitmap_manager_.get(), 128 NULL, 129 0, 130 false, 131 1, 132 false); 133 host_impl_ = make_scoped_ptr( 134 new FakeLayerTreeHostImpl(proxy_, shared_bitmap_manager_.get())); 135 } 136 137 virtual ~TiledLayerTest() { 138 ResourceManagerClearAllMemory(resource_manager_.get(), 139 resource_provider_.get()); 140 141 DebugScopedSetImplThreadAndMainThreadBlocked 142 impl_thread_and_main_thread_blocked(proxy_); 143 resource_provider_.reset(); 144 host_impl_.reset(); 145 } 146 147 void ResourceManagerClearAllMemory( 148 PrioritizedResourceManager* resource_manager, 149 ResourceProvider* resource_provider) { 150 { 151 DebugScopedSetImplThreadAndMainThreadBlocked 152 impl_thread_and_main_thread_blocked(proxy_); 153 resource_manager->ClearAllMemory(resource_provider); 154 resource_manager->ReduceMemory(resource_provider); 155 } 156 resource_manager->UnlinkAndClearEvictedBackings(); 157 } 158 159 void UpdateTextures() { 160 DebugScopedSetImplThreadAndMainThreadBlocked 161 impl_thread_and_main_thread_blocked(proxy_); 162 DCHECK(queue_); 163 scoped_ptr<ResourceUpdateController> update_controller = 164 ResourceUpdateController::Create(NULL, 165 proxy_->ImplThreadTaskRunner(), 166 queue_.Pass(), 167 resource_provider_.get()); 168 update_controller->Finalize(); 169 queue_ = make_scoped_ptr(new ResourceUpdateQueue); 170 } 171 172 void LayerPushPropertiesTo(FakeTiledLayer* layer, 173 FakeTiledLayerImpl* layer_impl) { 174 DebugScopedSetImplThreadAndMainThreadBlocked 175 impl_thread_and_main_thread_blocked(proxy_); 176 layer->PushPropertiesTo(layer_impl); 177 layer->ResetNumDependentsNeedPushProperties(); 178 } 179 180 void LayerUpdate(FakeTiledLayer* layer, TestOcclusionTracker* occluded) { 181 DebugScopedSetMainThread main_thread(proxy_); 182 layer->Update(queue_.get(), occluded); 183 } 184 185 void CalcDrawProps(RenderSurfaceLayerList* render_surface_layer_list) { 186 if (occlusion_) 187 occlusion_->SetRenderTarget(layer_tree_host_->root_layer()); 188 189 LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs( 190 layer_tree_host_->root_layer(), 191 layer_tree_host_->device_viewport_size(), 192 render_surface_layer_list); 193 inputs.device_scale_factor = layer_tree_host_->device_scale_factor(); 194 inputs.max_texture_size = 195 layer_tree_host_->GetRendererCapabilities().max_texture_size; 196 inputs.can_adjust_raster_scales = true; 197 LayerTreeHostCommon::CalculateDrawProperties(&inputs); 198 } 199 200 bool UpdateAndPush(const scoped_refptr<FakeTiledLayer>& layer1, 201 const scoped_ptr<FakeTiledLayerImpl>& layer_impl1) { 202 scoped_refptr<FakeTiledLayer> layer2; 203 scoped_ptr<FakeTiledLayerImpl> layer_impl2; 204 return UpdateAndPush(layer1, layer_impl1, layer2, layer_impl2); 205 } 206 207 bool UpdateAndPush(const scoped_refptr<FakeTiledLayer>& layer1, 208 const scoped_ptr<FakeTiledLayerImpl>& layer_impl1, 209 const scoped_refptr<FakeTiledLayer>& layer2, 210 const scoped_ptr<FakeTiledLayerImpl>& layer_impl2) { 211 // Get textures 212 resource_manager_->ClearPriorities(); 213 if (layer1.get()) 214 layer1->SetTexturePriorities(priority_calculator_); 215 if (layer2.get()) 216 layer2->SetTexturePriorities(priority_calculator_); 217 resource_manager_->PrioritizeTextures(); 218 219 // Save paint properties 220 if (layer1.get()) 221 layer1->SavePaintProperties(); 222 if (layer2.get()) 223 layer2->SavePaintProperties(); 224 225 // Update content 226 if (layer1.get()) 227 layer1->Update(queue_.get(), occlusion_); 228 if (layer2.get()) 229 layer2->Update(queue_.get(), occlusion_); 230 231 bool needs_update = false; 232 if (layer1.get()) 233 needs_update |= layer1->NeedsIdlePaint(); 234 if (layer2.get()) 235 needs_update |= layer2->NeedsIdlePaint(); 236 237 // Update textures and push. 238 UpdateTextures(); 239 if (layer1.get()) 240 LayerPushPropertiesTo(layer1.get(), layer_impl1.get()); 241 if (layer2.get()) 242 LayerPushPropertiesTo(layer2.get(), layer_impl2.get()); 243 244 return needs_update; 245 } 246 247 public: 248 Proxy* proxy_; 249 LayerTreeSettings settings_; 250 FakeOutputSurfaceClient output_surface_client_; 251 scoped_ptr<OutputSurface> output_surface_; 252 scoped_ptr<SharedBitmapManager> shared_bitmap_manager_; 253 scoped_ptr<ResourceProvider> resource_provider_; 254 scoped_ptr<ResourceUpdateQueue> queue_; 255 PriorityCalculator priority_calculator_; 256 base::Thread impl_thread_; 257 FakeLayerTreeHostClient fake_layer_tree_host_client_; 258 scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> layer_tree_host_; 259 scoped_ptr<FakeLayerTreeHostImpl> host_impl_; 260 scoped_ptr<PrioritizedResourceManager> resource_manager_; 261 TestOcclusionTracker* occlusion_; 262 }; 263 264 TEST_F(TiledLayerTest, PushDirtyTiles) { 265 scoped_refptr<FakeTiledLayer> layer = 266 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 267 scoped_ptr<FakeTiledLayerImpl> layer_impl = 268 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 269 RenderSurfaceLayerList render_surface_layer_list; 270 271 layer_tree_host_->root_layer()->AddChild(layer); 272 273 // The tile size is 100x100, so this invalidates and then paints two tiles. 274 layer->SetBounds(gfx::Size(100, 200)); 275 CalcDrawProps(&render_surface_layer_list); 276 UpdateAndPush(layer, layer_impl); 277 278 // We should have both tiles on the impl side. 279 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 280 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 281 282 // Invalidates both tiles, but then only update one of them. 283 layer->InvalidateContentRect(gfx::Rect(0, 0, 100, 200)); 284 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100); 285 UpdateAndPush(layer, layer_impl); 286 287 // We should only have the first tile since the other tile was invalidated but 288 // not painted. 289 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 290 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1)); 291 } 292 293 TEST_F(TiledLayerTest, Scale) { 294 layer_tree_host_->SetDeviceScaleFactor(1.5); 295 296 scoped_refptr<FakeTiledLayer> layer = 297 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 298 scoped_ptr<FakeTiledLayerImpl> layer_impl = 299 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 300 RenderSurfaceLayerList render_surface_layer_list; 301 302 layer_tree_host_->root_layer()->AddChild(layer); 303 304 layer->SetBounds(gfx::Size(100, 200)); 305 CalcDrawProps(&render_surface_layer_list); 306 307 // Change the width so that it doesn't divide cleanly by the scale. 308 layer->SetBounds(gfx::Size(101, 200)); 309 UpdateAndPush(layer, layer_impl); 310 311 EXPECT_EQ(1.5, layer->fake_layer_updater()->last_contents_width_scale()); 312 } 313 314 TEST_F(TiledLayerTest, PushOccludedDirtyTiles) { 315 scoped_refptr<FakeTiledLayer> layer = 316 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 317 scoped_ptr<FakeTiledLayerImpl> layer_impl = 318 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 319 TestOcclusionTracker occluded; 320 occlusion_ = &occluded; 321 layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000)); 322 323 layer_tree_host_->root_layer()->AddChild(layer); 324 325 { 326 RenderSurfaceLayerList render_surface_layer_list; 327 328 // The tile size is 100x100, so this invalidates and then paints two tiles. 329 layer->SetBounds(gfx::Size(100, 200)); 330 CalcDrawProps(&render_surface_layer_list); 331 UpdateAndPush(layer, layer_impl); 332 333 // We should have both tiles on the impl side. 334 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 335 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 336 } 337 338 { 339 RenderSurfaceLayerList render_surface_layer_list; 340 341 // Invalidates part of the top tile... 342 layer->InvalidateContentRect(gfx::Rect(0, 0, 50, 50)); 343 // ....but the area is occluded. 344 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(0, 0, 50, 50))); 345 CalcDrawProps(&render_surface_layer_list); 346 UpdateAndPush(layer, layer_impl); 347 348 // We should still have both tiles, as part of the top tile is still 349 // unoccluded. 350 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 351 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 352 } 353 } 354 355 TEST_F(TiledLayerTest, PushDeletedTiles) { 356 scoped_refptr<FakeTiledLayer> layer = 357 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 358 scoped_ptr<FakeTiledLayerImpl> layer_impl = 359 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 360 RenderSurfaceLayerList render_surface_layer_list; 361 362 layer_tree_host_->root_layer()->AddChild(layer); 363 364 // The tile size is 100x100, so this invalidates and then paints two tiles. 365 layer->SetBounds(gfx::Size(100, 200)); 366 CalcDrawProps(&render_surface_layer_list); 367 UpdateAndPush(layer, layer_impl); 368 369 // We should have both tiles on the impl side. 370 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 371 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 372 373 resource_manager_->ClearPriorities(); 374 ResourceManagerClearAllMemory(resource_manager_.get(), 375 resource_provider_.get()); 376 resource_manager_->SetMaxMemoryLimitBytes(4 * 1024 * 1024); 377 378 // This should drop the tiles on the impl thread. 379 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 380 381 // We should now have no textures on the impl thread. 382 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 0)); 383 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1)); 384 385 // This should recreate and update one of the deleted textures. 386 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100); 387 UpdateAndPush(layer, layer_impl); 388 389 // We should have one tiles on the impl side. 390 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 391 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1)); 392 } 393 394 TEST_F(TiledLayerTest, PushIdlePaintTiles) { 395 scoped_refptr<FakeTiledLayer> layer = 396 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 397 scoped_ptr<FakeTiledLayerImpl> layer_impl = 398 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 399 RenderSurfaceLayerList render_surface_layer_list; 400 401 layer_tree_host_->root_layer()->AddChild(layer); 402 403 // The tile size is 100x100. Setup 5x5 tiles with one visible tile in the 404 // center. This paints 1 visible of the 25 invalid tiles. 405 layer->SetBounds(gfx::Size(500, 500)); 406 CalcDrawProps(&render_surface_layer_list); 407 layer->draw_properties().visible_content_rect = gfx::Rect(200, 200, 100, 100); 408 bool needs_update = UpdateAndPush(layer, layer_impl); 409 // We should need idle-painting for surrounding tiles. 410 EXPECT_TRUE(needs_update); 411 412 // We should have one tile on the impl side. 413 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(2, 2)); 414 415 // For the next four updates, we should detect we still need idle painting. 416 for (int i = 0; i < 4; i++) { 417 needs_update = UpdateAndPush(layer, layer_impl); 418 EXPECT_TRUE(needs_update); 419 } 420 421 // We should always finish painting eventually. 422 for (int i = 0; i < 20; i++) 423 needs_update = UpdateAndPush(layer, layer_impl); 424 425 // We should have pre-painted all of the surrounding tiles. 426 for (int i = 0; i < 5; i++) { 427 for (int j = 0; j < 5; j++) 428 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(i, j)); 429 } 430 431 EXPECT_FALSE(needs_update); 432 } 433 434 TEST_F(TiledLayerTest, PredictivePainting) { 435 scoped_refptr<FakeTiledLayer> layer = 436 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 437 scoped_ptr<FakeTiledLayerImpl> layer_impl = 438 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 439 440 layer_tree_host_->root_layer()->AddChild(layer); 441 442 // Prepainting should occur in the scroll direction first, and the 443 // visible rect should be extruded only along the dominant axis. 444 gfx::Vector2d directions[6] = { gfx::Vector2d(-10, 0), gfx::Vector2d(10, 0), 445 gfx::Vector2d(0, -10), gfx::Vector2d(0, 10), 446 gfx::Vector2d(10, 20), 447 gfx::Vector2d(-20, 10) }; 448 // We should push all tiles that touch the extruded visible rect. 449 gfx::Rect pushed_visible_tiles[6] = { 450 gfx::Rect(2, 2, 2, 1), gfx::Rect(1, 2, 2, 1), gfx::Rect(2, 2, 1, 2), 451 gfx::Rect(2, 1, 1, 2), gfx::Rect(2, 1, 1, 2), gfx::Rect(2, 2, 2, 1) 452 }; 453 // The first pre-paint should also paint first in the scroll 454 // direction so we should find one additional tile in the scroll direction. 455 gfx::Rect pushed_prepaint_tiles[6] = { 456 gfx::Rect(2, 2, 3, 1), gfx::Rect(0, 2, 3, 1), gfx::Rect(2, 2, 1, 3), 457 gfx::Rect(2, 0, 1, 3), gfx::Rect(2, 0, 1, 3), gfx::Rect(2, 2, 3, 1) 458 }; 459 for (int k = 0; k < 6; k++) { 460 // The tile size is 100x100. Setup 5x5 tiles with one visible tile 461 // in the center. 462 gfx::Size bounds = gfx::Size(500, 500); 463 gfx::Rect visible_rect = gfx::Rect(200, 200, 100, 100); 464 gfx::Rect previous_visible_rect = 465 gfx::Rect(visible_rect.origin() + directions[k], visible_rect.size()); 466 gfx::Rect next_visible_rect = 467 gfx::Rect(visible_rect.origin() - directions[k], visible_rect.size()); 468 469 // Setup. Use the previous_visible_rect to setup the prediction for next 470 // frame. 471 layer->SetBounds(bounds); 472 473 RenderSurfaceLayerList render_surface_layer_list; 474 CalcDrawProps(&render_surface_layer_list); 475 layer->draw_properties().visible_content_rect = previous_visible_rect; 476 bool needs_update = UpdateAndPush(layer, layer_impl); 477 478 // Invalidate and move the visible_rect in the scroll direction. 479 // Check that the correct tiles have been painted in the visible pass. 480 layer->SetNeedsDisplay(); 481 layer->draw_properties().visible_content_rect = visible_rect; 482 needs_update = UpdateAndPush(layer, layer_impl); 483 for (int i = 0; i < 5; i++) { 484 for (int j = 0; j < 5; j++) 485 EXPECT_EQ(layer_impl->HasResourceIdForTileAt(i, j), 486 pushed_visible_tiles[k].Contains(i, j)); 487 } 488 489 // Move the transform in the same direction without invalidating. 490 // Check that non-visible pre-painting occured in the correct direction. 491 // Ignore diagonal scrolls here (k > 3) as these have new visible content 492 // now. 493 if (k <= 3) { 494 layer->draw_properties().visible_content_rect = next_visible_rect; 495 needs_update = UpdateAndPush(layer, layer_impl); 496 for (int i = 0; i < 5; i++) { 497 for (int j = 0; j < 5; j++) 498 EXPECT_EQ(layer_impl->HasResourceIdForTileAt(i, j), 499 pushed_prepaint_tiles[k].Contains(i, j)); 500 } 501 } 502 503 // We should always finish painting eventually. 504 for (int i = 0; i < 20; i++) 505 needs_update = UpdateAndPush(layer, layer_impl); 506 EXPECT_FALSE(needs_update); 507 } 508 } 509 510 TEST_F(TiledLayerTest, PushTilesAfterIdlePaintFailed) { 511 // Start with 2mb of memory, but the test is going to try to use just more 512 // than 1mb, so we reduce to 1mb later. 513 resource_manager_->SetMaxMemoryLimitBytes(2 * 1024 * 1024); 514 scoped_refptr<FakeTiledLayer> layer1 = 515 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 516 scoped_ptr<FakeTiledLayerImpl> layer_impl1 = 517 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 518 scoped_refptr<FakeTiledLayer> layer2 = 519 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 520 scoped_ptr<FakeTiledLayerImpl> layer_impl2 = 521 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2)); 522 RenderSurfaceLayerList render_surface_layer_list; 523 524 layer_tree_host_->root_layer()->AddChild(layer1); 525 layer_tree_host_->root_layer()->AddChild(layer2); 526 527 // For this test we have two layers. layer1 exhausts most texture memory, 528 // leaving room for 2 more tiles from layer2, but not all three tiles. First 529 // we paint layer1, and one tile from layer2. Then when we idle paint layer2, 530 // we will fail on the third tile of layer2, and this should not leave the 531 // second tile in a bad state. 532 533 // This uses 960000 bytes, leaving 88576 bytes of memory left, which is enough 534 // for 2 tiles only in the other layer. 535 gfx::Rect layer1_rect(0, 0, 100, 2400); 536 537 // This requires 4*30000 bytes of memory. 538 gfx::Rect layer2_rect(0, 0, 100, 300); 539 540 // Paint a single tile in layer2 so that it will idle paint. 541 layer1->SetBounds(layer1_rect.size()); 542 layer2->SetBounds(layer2_rect.size()); 543 CalcDrawProps(&render_surface_layer_list); 544 layer1->draw_properties().visible_content_rect = layer1_rect; 545 layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100); 546 bool needs_update = UpdateAndPush(layer1, layer_impl1, layer2, layer_impl2); 547 // We should need idle-painting for both remaining tiles in layer2. 548 EXPECT_TRUE(needs_update); 549 550 // Reduce our memory limits to 1mb. 551 resource_manager_->SetMaxMemoryLimitBytes(1024 * 1024); 552 553 // Now idle paint layer2. We are going to run out of memory though! 554 // Oh well, commit the frame and push. 555 for (int i = 0; i < 4; i++) { 556 needs_update = UpdateAndPush(layer1, layer_impl1, layer2, layer_impl2); 557 } 558 559 // Sanity check, we should have textures for the big layer. 560 EXPECT_TRUE(layer_impl1->HasResourceIdForTileAt(0, 0)); 561 EXPECT_TRUE(layer_impl1->HasResourceIdForTileAt(0, 23)); 562 563 // We should only have the first two tiles from layer2 since 564 // it failed to idle update the last tile. 565 EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 0)); 566 EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 0)); 567 EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 1)); 568 EXPECT_TRUE(layer_impl2->HasResourceIdForTileAt(0, 1)); 569 570 EXPECT_FALSE(needs_update); 571 EXPECT_FALSE(layer_impl2->HasResourceIdForTileAt(0, 2)); 572 } 573 574 TEST_F(TiledLayerTest, PushIdlePaintedOccludedTiles) { 575 scoped_refptr<FakeTiledLayer> layer = 576 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 577 scoped_ptr<FakeTiledLayerImpl> layer_impl = 578 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 579 RenderSurfaceLayerList render_surface_layer_list; 580 TestOcclusionTracker occluded; 581 occlusion_ = &occluded; 582 583 layer_tree_host_->root_layer()->AddChild(layer); 584 585 // The tile size is 100x100, so this invalidates one occluded tile, culls it 586 // during paint, but prepaints it. 587 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(0, 0, 100, 100))); 588 589 layer->SetBounds(gfx::Size(100, 100)); 590 CalcDrawProps(&render_surface_layer_list); 591 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100); 592 UpdateAndPush(layer, layer_impl); 593 594 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 595 } 596 597 TEST_F(TiledLayerTest, PushTilesMarkedDirtyDuringPaint) { 598 scoped_refptr<FakeTiledLayer> layer = 599 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 600 scoped_ptr<FakeTiledLayerImpl> layer_impl = 601 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 602 RenderSurfaceLayerList render_surface_layer_list; 603 604 layer_tree_host_->root_layer()->AddChild(layer); 605 606 // The tile size is 100x100, so this invalidates and then paints two tiles. 607 // However, during the paint, we invalidate one of the tiles. This should 608 // not prevent the tile from being pushed. 609 layer->fake_layer_updater()->SetRectToInvalidate( 610 gfx::Rect(0, 50, 100, 50), layer.get()); 611 layer->SetBounds(gfx::Size(100, 200)); 612 CalcDrawProps(&render_surface_layer_list); 613 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200); 614 UpdateAndPush(layer, layer_impl); 615 616 // We should have both tiles on the impl side. 617 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 618 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 619 } 620 621 TEST_F(TiledLayerTest, PushTilesLayerMarkedDirtyDuringPaintOnNextLayer) { 622 scoped_refptr<FakeTiledLayer> layer1 = 623 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 624 scoped_refptr<FakeTiledLayer> layer2 = 625 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 626 scoped_ptr<FakeTiledLayerImpl> layer1_impl = 627 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 628 scoped_ptr<FakeTiledLayerImpl> layer2_impl = 629 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2)); 630 RenderSurfaceLayerList render_surface_layer_list; 631 632 layer_tree_host_->root_layer()->AddChild(layer1); 633 layer_tree_host_->root_layer()->AddChild(layer2); 634 635 // Invalidate a tile on layer1, during update of layer 2. 636 layer2->fake_layer_updater()->SetRectToInvalidate( 637 gfx::Rect(0, 50, 100, 50), layer1.get()); 638 layer1->SetBounds(gfx::Size(100, 200)); 639 layer2->SetBounds(gfx::Size(100, 200)); 640 CalcDrawProps(&render_surface_layer_list); 641 layer1->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200); 642 layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200); 643 UpdateAndPush(layer1, layer1_impl, layer2, layer2_impl); 644 645 // We should have both tiles on the impl side for all layers. 646 EXPECT_TRUE(layer1_impl->HasResourceIdForTileAt(0, 0)); 647 EXPECT_TRUE(layer1_impl->HasResourceIdForTileAt(0, 1)); 648 EXPECT_TRUE(layer2_impl->HasResourceIdForTileAt(0, 0)); 649 EXPECT_TRUE(layer2_impl->HasResourceIdForTileAt(0, 1)); 650 } 651 652 TEST_F(TiledLayerTest, PushTilesLayerMarkedDirtyDuringPaintOnPreviousLayer) { 653 scoped_refptr<FakeTiledLayer> layer1 = 654 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 655 scoped_refptr<FakeTiledLayer> layer2 = 656 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 657 scoped_ptr<FakeTiledLayerImpl> layer1_impl = 658 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 659 scoped_ptr<FakeTiledLayerImpl> layer2_impl = 660 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2)); 661 RenderSurfaceLayerList render_surface_layer_list; 662 663 layer_tree_host_->root_layer()->AddChild(layer1); 664 layer_tree_host_->root_layer()->AddChild(layer2); 665 666 layer1->fake_layer_updater()->SetRectToInvalidate( 667 gfx::Rect(0, 50, 100, 50), layer2.get()); 668 layer1->SetBounds(gfx::Size(100, 200)); 669 layer2->SetBounds(gfx::Size(100, 200)); 670 CalcDrawProps(&render_surface_layer_list); 671 layer1->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200); 672 layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200); 673 UpdateAndPush(layer1, layer1_impl, layer2, layer2_impl); 674 675 // We should have both tiles on the impl side for all layers. 676 EXPECT_TRUE(layer1_impl->HasResourceIdForTileAt(0, 0)); 677 EXPECT_TRUE(layer1_impl->HasResourceIdForTileAt(0, 1)); 678 EXPECT_TRUE(layer2_impl->HasResourceIdForTileAt(0, 0)); 679 EXPECT_TRUE(layer2_impl->HasResourceIdForTileAt(0, 1)); 680 } 681 682 TEST_F(TiledLayerTest, PaintSmallAnimatedLayersImmediately) { 683 // Create a LayerTreeHost that has the right viewportsize, 684 // so the layer is considered small enough. 685 bool run_out_of_memory[2] = { false, true }; 686 for (int i = 0; i < 2; i++) { 687 // Create a layer with 5x5 tiles, with 4x4 size viewport. 688 int viewport_width = 4 * FakeTiledLayer::tile_size().width(); 689 int viewport_height = 4 * FakeTiledLayer::tile_size().width(); 690 int layer_width = 5 * FakeTiledLayer::tile_size().width(); 691 int layer_height = 5 * FakeTiledLayer::tile_size().height(); 692 int memory_for_layer = layer_width * layer_height * 4; 693 layer_tree_host_->SetViewportSize( 694 gfx::Size(viewport_width, viewport_height)); 695 696 // Use 10x5 tiles to run out of memory. 697 if (run_out_of_memory[i]) 698 layer_width *= 2; 699 700 resource_manager_->SetMaxMemoryLimitBytes(memory_for_layer); 701 702 scoped_refptr<FakeTiledLayer> layer = 703 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 704 scoped_ptr<FakeTiledLayerImpl> layer_impl = 705 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 706 RenderSurfaceLayerList render_surface_layer_list; 707 708 layer_tree_host_->root_layer()->AddChild(layer); 709 710 // Full size layer with half being visible. 711 layer->SetBounds(gfx::Size(layer_width, layer_height)); 712 gfx::Rect visible_rect(0, 0, layer_width / 2, layer_height); 713 CalcDrawProps(&render_surface_layer_list); 714 715 // Pretend the layer is animating. 716 layer->draw_properties().target_space_transform_is_animating = true; 717 layer->draw_properties().visible_content_rect = visible_rect; 718 layer->SetLayerTreeHost(layer_tree_host_.get()); 719 720 // The layer should paint its entire contents on the first paint 721 // if it is close to the viewport size and has the available memory. 722 layer->SetTexturePriorities(priority_calculator_); 723 resource_manager_->PrioritizeTextures(); 724 layer->SavePaintProperties(); 725 layer->Update(queue_.get(), NULL); 726 UpdateTextures(); 727 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 728 729 // We should have all the tiles for the small animated layer. 730 // We should still have the visible tiles when we didn't 731 // have enough memory for all the tiles. 732 if (!run_out_of_memory[i]) { 733 for (int i = 0; i < 5; ++i) { 734 for (int j = 0; j < 5; ++j) 735 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(i, j)); 736 } 737 } else { 738 for (int i = 0; i < 10; ++i) { 739 for (int j = 0; j < 5; ++j) 740 EXPECT_EQ(layer_impl->HasResourceIdForTileAt(i, j), i < 5); 741 } 742 } 743 744 layer->RemoveFromParent(); 745 } 746 } 747 748 TEST_F(TiledLayerTest, IdlePaintOutOfMemory) { 749 scoped_refptr<FakeTiledLayer> layer = 750 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 751 scoped_ptr<FakeTiledLayerImpl> layer_impl = 752 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 753 RenderSurfaceLayerList render_surface_layer_list; 754 755 layer_tree_host_->root_layer()->AddChild(layer); 756 757 // We have enough memory for only the visible rect, so we will run out of 758 // memory in first idle paint. 759 int memory_limit = 4 * 100 * 100; // 1 tiles, 4 bytes per pixel. 760 resource_manager_->SetMaxMemoryLimitBytes(memory_limit); 761 762 // The tile size is 100x100, so this invalidates and then paints two tiles. 763 bool needs_update = false; 764 layer->SetBounds(gfx::Size(300, 300)); 765 CalcDrawProps(&render_surface_layer_list); 766 layer->draw_properties().visible_content_rect = gfx::Rect(100, 100, 100, 100); 767 for (int i = 0; i < 2; i++) 768 needs_update = UpdateAndPush(layer, layer_impl); 769 770 // Idle-painting should see no more priority tiles for painting. 771 EXPECT_FALSE(needs_update); 772 773 // We should have one tile on the impl side. 774 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 1)); 775 } 776 777 TEST_F(TiledLayerTest, IdlePaintZeroSizedLayer) { 778 scoped_refptr<FakeTiledLayer> layer = 779 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 780 scoped_ptr<FakeTiledLayerImpl> layer_impl = 781 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 782 783 layer_tree_host_->root_layer()->AddChild(layer); 784 785 bool animating[2] = { false, true }; 786 for (int i = 0; i < 2; i++) { 787 // Pretend the layer is animating. 788 layer->draw_properties().target_space_transform_is_animating = animating[i]; 789 790 // The layer's bounds are empty. 791 // Empty layers don't paint or idle-paint. 792 layer->SetBounds(gfx::Size()); 793 794 RenderSurfaceLayerList render_surface_layer_list; 795 CalcDrawProps(&render_surface_layer_list); 796 layer->draw_properties().visible_content_rect = gfx::Rect(); 797 bool needs_update = UpdateAndPush(layer, layer_impl); 798 799 // Empty layers don't have tiles. 800 EXPECT_EQ(0u, layer->NumPaintedTiles()); 801 802 // Empty layers don't need prepaint. 803 EXPECT_FALSE(needs_update); 804 805 // Empty layers don't have tiles. 806 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 0)); 807 } 808 } 809 810 TEST_F(TiledLayerTest, IdlePaintNonVisibleLayers) { 811 scoped_refptr<FakeTiledLayer> layer = 812 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 813 scoped_ptr<FakeTiledLayerImpl> layer_impl = 814 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 815 816 // Alternate between not visible and visible. 817 gfx::Rect v(0, 0, 100, 100); 818 gfx::Rect nv(0, 0, 0, 0); 819 gfx::Rect visible_rect[10] = { nv, nv, v, v, nv, nv, v, v, nv, nv }; 820 bool invalidate[10] = { true, true, true, true, true, true, true, true, false, 821 false }; 822 823 // We should not have any tiles except for when the layer was visible 824 // or after the layer was visible and we didn't invalidate. 825 bool have_tile[10] = { false, false, true, true, false, false, true, true, 826 true, true }; 827 828 layer_tree_host_->root_layer()->AddChild(layer); 829 830 for (int i = 0; i < 10; i++) { 831 layer->SetBounds(gfx::Size(100, 100)); 832 833 RenderSurfaceLayerList render_surface_layer_list; 834 CalcDrawProps(&render_surface_layer_list); 835 layer->draw_properties().visible_content_rect = visible_rect[i]; 836 837 if (invalidate[i]) 838 layer->InvalidateContentRect(gfx::Rect(0, 0, 100, 100)); 839 bool needs_update = UpdateAndPush(layer, layer_impl); 840 841 // We should never signal idle paint, as we painted the entire layer 842 // or the layer was not visible. 843 EXPECT_FALSE(needs_update); 844 EXPECT_EQ(layer_impl->HasResourceIdForTileAt(0, 0), have_tile[i]); 845 } 846 } 847 848 TEST_F(TiledLayerTest, InvalidateFromPrepare) { 849 scoped_refptr<FakeTiledLayer> layer = 850 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 851 scoped_ptr<FakeTiledLayerImpl> layer_impl = 852 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 853 RenderSurfaceLayerList render_surface_layer_list; 854 855 layer_tree_host_->root_layer()->AddChild(layer); 856 857 // The tile size is 100x100, so this invalidates and then paints two tiles. 858 layer->SetBounds(gfx::Size(100, 200)); 859 CalcDrawProps(&render_surface_layer_list); 860 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200); 861 UpdateAndPush(layer, layer_impl); 862 863 // We should have both tiles on the impl side. 864 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 865 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 866 867 layer->fake_layer_updater()->ClearPrepareCount(); 868 // Invoke update again. As the layer is valid update shouldn't be invoked on 869 // the LayerUpdater. 870 UpdateAndPush(layer, layer_impl); 871 EXPECT_EQ(0, layer->fake_layer_updater()->prepare_count()); 872 873 // SetRectToInvalidate triggers InvalidateContentRect() being invoked from 874 // update. 875 layer->fake_layer_updater()->SetRectToInvalidate( 876 gfx::Rect(25, 25, 50, 50), layer.get()); 877 layer->fake_layer_updater()->ClearPrepareCount(); 878 layer->InvalidateContentRect(gfx::Rect(0, 0, 50, 50)); 879 UpdateAndPush(layer, layer_impl); 880 EXPECT_EQ(1, layer->fake_layer_updater()->prepare_count()); 881 layer->fake_layer_updater()->ClearPrepareCount(); 882 883 // The layer should still be invalid as update invoked invalidate. 884 UpdateAndPush(layer, layer_impl); // visible 885 EXPECT_EQ(1, layer->fake_layer_updater()->prepare_count()); 886 } 887 888 TEST_F(TiledLayerTest, VerifyUpdateRectWhenContentBoundsAreScaled) { 889 // The update rect (that indicates what was actually painted) should be in 890 // layer space, not the content space. 891 scoped_refptr<FakeTiledLayerWithScaledBounds> layer = make_scoped_refptr( 892 new FakeTiledLayerWithScaledBounds(resource_manager_.get())); 893 894 layer_tree_host_->root_layer()->AddChild(layer); 895 896 gfx::Rect layer_bounds(0, 0, 300, 200); 897 gfx::Rect content_bounds(0, 0, 150, 250); 898 899 layer->SetBounds(layer_bounds.size()); 900 layer->SetContentBounds(content_bounds.size()); 901 layer->draw_properties().visible_content_rect = content_bounds; 902 layer->draw_properties().contents_scale_x = .5f; 903 layer->draw_properties().contents_scale_y = 1.25f; 904 905 // On first update, the update_rect includes all tiles, even beyond the 906 // boundaries of the layer. 907 // However, it should still be in layer space, not content space. 908 layer->InvalidateContentRect(content_bounds); 909 910 layer->SetTexturePriorities(priority_calculator_); 911 resource_manager_->PrioritizeTextures(); 912 layer->SavePaintProperties(); 913 layer->Update(queue_.get(), NULL); 914 915 // Update rect is 200x300 (tile size of 100x100). Scaled this gives 400x240. 916 EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 400, 240), layer->update_rect()); 917 UpdateTextures(); 918 919 // After the tiles are updated once, another invalidate only needs to update 920 // the bounds of the layer. 921 layer->SetTexturePriorities(priority_calculator_); 922 resource_manager_->PrioritizeTextures(); 923 layer->InvalidateContentRect(content_bounds); 924 layer->SavePaintProperties(); 925 layer->Update(queue_.get(), NULL); 926 EXPECT_FLOAT_RECT_EQ(gfx::RectF(layer_bounds), layer->update_rect()); 927 UpdateTextures(); 928 929 // Partial re-paint should also be represented by the update rect in layer 930 // space, not content space. 931 gfx::Rect partial_damage(30, 100, 10, 10); 932 layer->InvalidateContentRect(partial_damage); 933 layer->SetTexturePriorities(priority_calculator_); 934 resource_manager_->PrioritizeTextures(); 935 layer->SavePaintProperties(); 936 layer->Update(queue_.get(), NULL); 937 EXPECT_FLOAT_RECT_EQ(gfx::RectF(60, 80, 20, 8), layer->update_rect()); 938 } 939 940 TEST_F(TiledLayerTest, VerifyInvalidationWhenContentsScaleChanges) { 941 scoped_refptr<FakeTiledLayer> layer = 942 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 943 scoped_ptr<FakeTiledLayerImpl> layer_impl = 944 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 945 RenderSurfaceLayerList render_surface_layer_list; 946 947 layer_tree_host_->root_layer()->AddChild(layer); 948 949 // Create a layer with one tile. 950 layer->SetBounds(gfx::Size(100, 100)); 951 CalcDrawProps(&render_surface_layer_list); 952 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100); 953 layer->Update(queue_.get(), NULL); 954 UpdateTextures(); 955 EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100), 956 layer->last_needs_display_rect()); 957 958 // Push the tiles to the impl side and check that there is exactly one. 959 layer->SetTexturePriorities(priority_calculator_); 960 resource_manager_->PrioritizeTextures(); 961 layer->SavePaintProperties(); 962 layer->Update(queue_.get(), NULL); 963 UpdateTextures(); 964 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 965 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 966 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1)); 967 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 0)); 968 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 1)); 969 970 layer->SetNeedsDisplayRect(gfx::Rect()); 971 EXPECT_FLOAT_RECT_EQ(gfx::RectF(), layer->last_needs_display_rect()); 972 973 // Change the contents scale. 974 layer->UpdateContentsScale(2.f); 975 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 200, 200); 976 977 // The impl side should get 2x2 tiles now. 978 layer->SetTexturePriorities(priority_calculator_); 979 resource_manager_->PrioritizeTextures(); 980 layer->SavePaintProperties(); 981 layer->Update(queue_.get(), NULL); 982 UpdateTextures(); 983 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 984 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0)); 985 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1)); 986 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 0)); 987 EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 1)); 988 989 // Verify that changing the contents scale caused invalidation, and 990 // that the layer-space rectangle requiring painting is not scaled. 991 EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100), 992 layer->last_needs_display_rect()); 993 994 // Invalidate the entire layer again, but do not paint. All tiles should be 995 // gone now from the impl side. 996 layer->SetNeedsDisplay(); 997 layer->SetTexturePriorities(priority_calculator_); 998 resource_manager_->PrioritizeTextures(); 999 1000 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1001 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 0)); 1002 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1)); 1003 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 0)); 1004 EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 1)); 1005 } 1006 1007 TEST_F(TiledLayerTest, SkipsDrawGetsReset) { 1008 // Create two 300 x 300 tiled layers. 1009 gfx::Size content_bounds(300, 300); 1010 gfx::Rect content_rect(content_bounds); 1011 1012 // We have enough memory for only one of the two layers. 1013 int memory_limit = 4 * 300 * 300; // 4 bytes per pixel. 1014 1015 scoped_refptr<FakeTiledLayer> root_layer = make_scoped_refptr( 1016 new FakeTiledLayer(layer_tree_host_->contents_texture_manager())); 1017 scoped_refptr<FakeTiledLayer> child_layer = make_scoped_refptr( 1018 new FakeTiledLayer(layer_tree_host_->contents_texture_manager())); 1019 root_layer->AddChild(child_layer); 1020 1021 root_layer->SetBounds(content_bounds); 1022 root_layer->draw_properties().visible_content_rect = content_rect; 1023 root_layer->SetPosition(gfx::PointF(0, 0)); 1024 child_layer->SetBounds(content_bounds); 1025 child_layer->draw_properties().visible_content_rect = content_rect; 1026 child_layer->SetPosition(gfx::PointF(0, 0)); 1027 root_layer->InvalidateContentRect(content_rect); 1028 child_layer->InvalidateContentRect(content_rect); 1029 1030 layer_tree_host_->SetRootLayer(root_layer); 1031 layer_tree_host_->SetViewportSize(gfx::Size(300, 300)); 1032 layer_tree_host_->contents_texture_manager()->SetMaxMemoryLimitBytes( 1033 memory_limit); 1034 1035 layer_tree_host_->UpdateLayers(queue_.get()); 1036 1037 // We'll skip the root layer. 1038 EXPECT_TRUE(root_layer->SkipsDraw()); 1039 EXPECT_FALSE(child_layer->SkipsDraw()); 1040 1041 layer_tree_host_->CommitComplete(); 1042 1043 // Remove the child layer. 1044 root_layer->RemoveAllChildren(); 1045 1046 layer_tree_host_->UpdateLayers(queue_.get()); 1047 EXPECT_FALSE(root_layer->SkipsDraw()); 1048 1049 ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(), 1050 resource_provider_.get()); 1051 layer_tree_host_->SetRootLayer(NULL); 1052 } 1053 1054 TEST_F(TiledLayerTest, ResizeToSmaller) { 1055 scoped_refptr<FakeTiledLayer> layer = 1056 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1057 1058 layer_tree_host_->root_layer()->AddChild(layer); 1059 1060 layer->SetBounds(gfx::Size(700, 700)); 1061 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700); 1062 layer->InvalidateContentRect(gfx::Rect(0, 0, 700, 700)); 1063 1064 layer->SetTexturePriorities(priority_calculator_); 1065 resource_manager_->PrioritizeTextures(); 1066 layer->SavePaintProperties(); 1067 layer->Update(queue_.get(), NULL); 1068 1069 layer->SetBounds(gfx::Size(200, 200)); 1070 layer->InvalidateContentRect(gfx::Rect(0, 0, 200, 200)); 1071 } 1072 1073 TEST_F(TiledLayerTest, HugeLayerUpdateCrash) { 1074 scoped_refptr<FakeTiledLayer> layer = 1075 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1076 1077 layer_tree_host_->root_layer()->AddChild(layer); 1078 1079 int size = 1 << 30; 1080 layer->SetBounds(gfx::Size(size, size)); 1081 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700); 1082 layer->InvalidateContentRect(gfx::Rect(0, 0, size, size)); 1083 1084 // Ensure no crash for bounds where size * size would overflow an int. 1085 layer->SetTexturePriorities(priority_calculator_); 1086 resource_manager_->PrioritizeTextures(); 1087 layer->SavePaintProperties(); 1088 layer->Update(queue_.get(), NULL); 1089 } 1090 1091 class TiledLayerPartialUpdateTest : public TiledLayerTest { 1092 public: 1093 TiledLayerPartialUpdateTest() { settings_.max_partial_texture_updates = 4; } 1094 }; 1095 1096 TEST_F(TiledLayerPartialUpdateTest, PartialUpdates) { 1097 // Create one 300 x 200 tiled layer with 3 x 2 tiles. 1098 gfx::Size content_bounds(300, 200); 1099 gfx::Rect content_rect(content_bounds); 1100 1101 scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr( 1102 new FakeTiledLayer(layer_tree_host_->contents_texture_manager())); 1103 layer->SetBounds(content_bounds); 1104 layer->SetPosition(gfx::PointF(0, 0)); 1105 layer->draw_properties().visible_content_rect = content_rect; 1106 layer->InvalidateContentRect(content_rect); 1107 1108 layer_tree_host_->SetRootLayer(layer); 1109 layer_tree_host_->SetViewportSize(gfx::Size(300, 200)); 1110 1111 // Full update of all 6 tiles. 1112 layer_tree_host_->UpdateLayers(queue_.get()); 1113 { 1114 scoped_ptr<FakeTiledLayerImpl> layer_impl = 1115 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 1116 EXPECT_EQ(6u, queue_->FullUploadSize()); 1117 EXPECT_EQ(0u, queue_->PartialUploadSize()); 1118 UpdateTextures(); 1119 EXPECT_EQ(6, layer->fake_layer_updater()->update_count()); 1120 EXPECT_FALSE(queue_->HasMoreUpdates()); 1121 layer->fake_layer_updater()->ClearUpdateCount(); 1122 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1123 } 1124 layer_tree_host_->CommitComplete(); 1125 1126 // Full update of 3 tiles and partial update of 3 tiles. 1127 layer->InvalidateContentRect(gfx::Rect(0, 0, 300, 150)); 1128 layer_tree_host_->UpdateLayers(queue_.get()); 1129 { 1130 scoped_ptr<FakeTiledLayerImpl> layer_impl = 1131 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 1132 EXPECT_EQ(3u, queue_->FullUploadSize()); 1133 EXPECT_EQ(3u, queue_->PartialUploadSize()); 1134 UpdateTextures(); 1135 EXPECT_EQ(6, layer->fake_layer_updater()->update_count()); 1136 EXPECT_FALSE(queue_->HasMoreUpdates()); 1137 layer->fake_layer_updater()->ClearUpdateCount(); 1138 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1139 } 1140 layer_tree_host_->CommitComplete(); 1141 1142 // Partial update of 6 tiles. 1143 layer->InvalidateContentRect(gfx::Rect(50, 50, 200, 100)); 1144 { 1145 scoped_ptr<FakeTiledLayerImpl> layer_impl = 1146 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 1147 layer_tree_host_->UpdateLayers(queue_.get()); 1148 EXPECT_EQ(2u, queue_->FullUploadSize()); 1149 EXPECT_EQ(4u, queue_->PartialUploadSize()); 1150 UpdateTextures(); 1151 EXPECT_EQ(6, layer->fake_layer_updater()->update_count()); 1152 EXPECT_FALSE(queue_->HasMoreUpdates()); 1153 layer->fake_layer_updater()->ClearUpdateCount(); 1154 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1155 } 1156 layer_tree_host_->CommitComplete(); 1157 1158 // Checkerboard all tiles. 1159 layer->InvalidateContentRect(gfx::Rect(0, 0, 300, 200)); 1160 { 1161 scoped_ptr<FakeTiledLayerImpl> layer_impl = 1162 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 1163 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1164 } 1165 layer_tree_host_->CommitComplete(); 1166 1167 // Partial update of 6 checkerboard tiles. 1168 layer->InvalidateContentRect(gfx::Rect(50, 50, 200, 100)); 1169 { 1170 scoped_ptr<FakeTiledLayerImpl> layer_impl = 1171 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 1172 layer_tree_host_->UpdateLayers(queue_.get()); 1173 EXPECT_EQ(6u, queue_->FullUploadSize()); 1174 EXPECT_EQ(0u, queue_->PartialUploadSize()); 1175 UpdateTextures(); 1176 EXPECT_EQ(6, layer->fake_layer_updater()->update_count()); 1177 EXPECT_FALSE(queue_->HasMoreUpdates()); 1178 layer->fake_layer_updater()->ClearUpdateCount(); 1179 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1180 } 1181 layer_tree_host_->CommitComplete(); 1182 1183 // Partial update of 4 tiles. 1184 layer->InvalidateContentRect(gfx::Rect(50, 50, 100, 100)); 1185 { 1186 scoped_ptr<FakeTiledLayerImpl> layer_impl = 1187 make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1)); 1188 layer_tree_host_->UpdateLayers(queue_.get()); 1189 EXPECT_EQ(0u, queue_->FullUploadSize()); 1190 EXPECT_EQ(4u, queue_->PartialUploadSize()); 1191 UpdateTextures(); 1192 EXPECT_EQ(4, layer->fake_layer_updater()->update_count()); 1193 EXPECT_FALSE(queue_->HasMoreUpdates()); 1194 layer->fake_layer_updater()->ClearUpdateCount(); 1195 LayerPushPropertiesTo(layer.get(), layer_impl.get()); 1196 } 1197 layer_tree_host_->CommitComplete(); 1198 1199 ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(), 1200 resource_provider_.get()); 1201 layer_tree_host_->SetRootLayer(NULL); 1202 } 1203 1204 TEST_F(TiledLayerTest, TilesPaintedWithoutOcclusion) { 1205 scoped_refptr<FakeTiledLayer> layer = 1206 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1207 RenderSurfaceLayerList render_surface_layer_list; 1208 1209 layer_tree_host_->root_layer()->AddChild(layer); 1210 1211 // The tile size is 100x100, so this invalidates and then paints two tiles. 1212 layer->SetBounds(gfx::Size(100, 200)); 1213 CalcDrawProps(&render_surface_layer_list); 1214 1215 layer->SetTexturePriorities(priority_calculator_); 1216 resource_manager_->PrioritizeTextures(); 1217 layer->SavePaintProperties(); 1218 layer->Update(queue_.get(), NULL); 1219 EXPECT_EQ(2, layer->fake_layer_updater()->update_count()); 1220 } 1221 1222 TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) { 1223 scoped_refptr<FakeTiledLayer> layer = 1224 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1225 RenderSurfaceLayerList render_surface_layer_list; 1226 TestOcclusionTracker occluded; 1227 occlusion_ = &occluded; 1228 1229 layer_tree_host_->root_layer()->AddChild(layer); 1230 1231 // The tile size is 100x100. 1232 1233 layer_tree_host_->SetViewportSize(gfx::Size(600, 600)); 1234 layer->SetBounds(gfx::Size(600, 600)); 1235 CalcDrawProps(&render_surface_layer_list); 1236 1237 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 100))); 1238 layer->draw_properties().drawable_content_rect = 1239 gfx::Rect(layer->content_bounds()); 1240 layer->draw_properties().visible_content_rect = 1241 gfx::Rect(layer->content_bounds()); 1242 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1243 1244 layer->SetTexturePriorities(priority_calculator_); 1245 resource_manager_->PrioritizeTextures(); 1246 layer->SavePaintProperties(); 1247 layer->Update(queue_.get(), &occluded); 1248 EXPECT_EQ(36 - 3, layer->fake_layer_updater()->update_count()); 1249 1250 layer->fake_layer_updater()->ClearUpdateCount(); 1251 layer->SetTexturePriorities(priority_calculator_); 1252 resource_manager_->PrioritizeTextures(); 1253 1254 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(250, 200, 300, 100))); 1255 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1256 layer->SavePaintProperties(); 1257 layer->Update(queue_.get(), &occluded); 1258 EXPECT_EQ(36 - 2, layer->fake_layer_updater()->update_count()); 1259 1260 layer->fake_layer_updater()->ClearUpdateCount(); 1261 layer->SetTexturePriorities(priority_calculator_); 1262 resource_manager_->PrioritizeTextures(); 1263 1264 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(250, 250, 300, 100))); 1265 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1266 layer->SavePaintProperties(); 1267 layer->Update(queue_.get(), &occluded); 1268 EXPECT_EQ(36, layer->fake_layer_updater()->update_count()); 1269 } 1270 1271 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) { 1272 scoped_refptr<FakeTiledLayer> layer = 1273 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1274 RenderSurfaceLayerList render_surface_layer_list; 1275 TestOcclusionTracker occluded; 1276 occlusion_ = &occluded; 1277 1278 layer_tree_host_->root_layer()->AddChild(layer); 1279 1280 // The tile size is 100x100. 1281 1282 layer_tree_host_->SetViewportSize(gfx::Size(600, 600)); 1283 layer->SetBounds(gfx::Size(600, 600)); 1284 CalcDrawProps(&render_surface_layer_list); 1285 1286 // The partially occluded tiles (by the 150 occlusion height) are visible 1287 // beyond the occlusion, so not culled. 1288 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 150))); 1289 layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 360); 1290 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 360); 1291 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1292 1293 layer->SetTexturePriorities(priority_calculator_); 1294 resource_manager_->PrioritizeTextures(); 1295 layer->SavePaintProperties(); 1296 layer->Update(queue_.get(), &occluded); 1297 EXPECT_EQ(24 - 3, layer->fake_layer_updater()->update_count()); 1298 1299 layer->fake_layer_updater()->ClearUpdateCount(); 1300 1301 // Now the visible region stops at the edge of the occlusion so the partly 1302 // visible tiles become fully occluded. 1303 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 150))); 1304 layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 350); 1305 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 350); 1306 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1307 layer->SetTexturePriorities(priority_calculator_); 1308 resource_manager_->PrioritizeTextures(); 1309 layer->SavePaintProperties(); 1310 layer->Update(queue_.get(), &occluded); 1311 EXPECT_EQ(24 - 6, layer->fake_layer_updater()->update_count()); 1312 1313 layer->fake_layer_updater()->ClearUpdateCount(); 1314 1315 // Now the visible region is even smaller than the occlusion, it should have 1316 // the same result. 1317 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 150))); 1318 layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 340); 1319 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 340); 1320 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1321 layer->SetTexturePriorities(priority_calculator_); 1322 resource_manager_->PrioritizeTextures(); 1323 layer->SavePaintProperties(); 1324 layer->Update(queue_.get(), &occluded); 1325 EXPECT_EQ(24 - 6, layer->fake_layer_updater()->update_count()); 1326 } 1327 1328 TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) { 1329 scoped_refptr<FakeTiledLayer> layer = 1330 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1331 RenderSurfaceLayerList render_surface_layer_list; 1332 TestOcclusionTracker occluded; 1333 occlusion_ = &occluded; 1334 1335 layer_tree_host_->root_layer()->AddChild(layer); 1336 1337 // The tile size is 100x100. 1338 1339 layer_tree_host_->SetViewportSize(gfx::Size(600, 600)); 1340 layer->SetBounds(gfx::Size(600, 600)); 1341 CalcDrawProps(&render_surface_layer_list); 1342 1343 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 100))); 1344 layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 600); 1345 layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 600); 1346 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1347 layer->SetTexturePriorities(priority_calculator_); 1348 resource_manager_->PrioritizeTextures(); 1349 layer->SavePaintProperties(); 1350 layer->Update(queue_.get(), &occluded); 1351 EXPECT_EQ(36 - 3, layer->fake_layer_updater()->update_count()); 1352 UpdateTextures(); 1353 1354 layer->fake_layer_updater()->ClearUpdateCount(); 1355 layer->SetTexturePriorities(priority_calculator_); 1356 resource_manager_->PrioritizeTextures(); 1357 layer->SavePaintProperties(); 1358 1359 // Repaint without marking it dirty. The 3 culled tiles will be pre-painted 1360 // now. 1361 layer->Update(queue_.get(), &occluded); 1362 EXPECT_EQ(3, layer->fake_layer_updater()->update_count()); 1363 } 1364 1365 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) { 1366 scoped_refptr<FakeTiledLayer> layer = 1367 make_scoped_refptr(new FakeTiledLayer(resource_manager_.get())); 1368 RenderSurfaceLayerList render_surface_layer_list; 1369 TestOcclusionTracker occluded; 1370 occlusion_ = &occluded; 1371 1372 layer_tree_host_->root_layer()->AddChild(layer); 1373 1374 // The tile size is 100x100. 1375 1376 // This makes sure the painting works when the occluded region (in screen 1377 // space) is transformed differently than the layer. 1378 layer_tree_host_->SetViewportSize(gfx::Size(600, 600)); 1379 layer->SetBounds(gfx::Size(600, 600)); 1380 CalcDrawProps(&render_surface_layer_list); 1381 gfx::Transform screen_transform; 1382 screen_transform.Scale(0.5, 0.5); 1383 layer->draw_properties().screen_space_transform = screen_transform; 1384 layer->draw_properties().target_space_transform = screen_transform; 1385 1386 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(100, 100, 150, 50))); 1387 layer->draw_properties().drawable_content_rect = 1388 gfx::Rect(layer->content_bounds()); 1389 layer->draw_properties().visible_content_rect = 1390 gfx::Rect(layer->content_bounds()); 1391 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1392 layer->SetTexturePriorities(priority_calculator_); 1393 resource_manager_->PrioritizeTextures(); 1394 layer->SavePaintProperties(); 1395 layer->Update(queue_.get(), &occluded); 1396 EXPECT_EQ(36 - 3, layer->fake_layer_updater()->update_count()); 1397 } 1398 1399 TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) { 1400 scoped_refptr<FakeTiledLayer> layer = 1401 new FakeTiledLayer(resource_manager_.get()); 1402 RenderSurfaceLayerList render_surface_layer_list; 1403 TestOcclusionTracker occluded; 1404 occlusion_ = &occluded; 1405 1406 scoped_refptr<FakeTiledLayer> scale_layer = 1407 new FakeTiledLayer(resource_manager_.get()); 1408 gfx::Transform scale_transform; 1409 scale_transform.Scale(2.0, 2.0); 1410 scale_layer->SetTransform(scale_transform); 1411 1412 layer_tree_host_->root_layer()->AddChild(scale_layer); 1413 1414 // The tile size is 100x100. 1415 1416 // This makes sure the painting works when the content space is scaled to 1417 // a different layer space. 1418 layer_tree_host_->SetViewportSize(gfx::Size(600, 600)); 1419 layer->SetBounds(gfx::Size(300, 300)); 1420 scale_layer->AddChild(layer); 1421 CalcDrawProps(&render_surface_layer_list); 1422 EXPECT_FLOAT_EQ(2.f, layer->contents_scale_x()); 1423 EXPECT_FLOAT_EQ(2.f, layer->contents_scale_y()); 1424 EXPECT_EQ(gfx::Size(600, 600).ToString(), 1425 layer->content_bounds().ToString()); 1426 1427 // No tiles are covered by the 300x50 occlusion. 1428 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 50))); 1429 layer->draw_properties().drawable_content_rect = 1430 gfx::Rect(layer->bounds()); 1431 layer->draw_properties().visible_content_rect = 1432 gfx::Rect(layer->content_bounds()); 1433 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1434 layer->SetTexturePriorities(priority_calculator_); 1435 resource_manager_->PrioritizeTextures(); 1436 layer->SavePaintProperties(); 1437 layer->Update(queue_.get(), &occluded); 1438 int visible_tiles1 = 6 * 6; 1439 EXPECT_EQ(visible_tiles1, layer->fake_layer_updater()->update_count()); 1440 1441 layer->fake_layer_updater()->ClearUpdateCount(); 1442 1443 // The occlusion of 300x100 will be cover 3 tiles as tiles are 100x100 still. 1444 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(200, 200, 300, 100))); 1445 layer->draw_properties().drawable_content_rect = 1446 gfx::Rect(layer->bounds()); 1447 layer->draw_properties().visible_content_rect = 1448 gfx::Rect(layer->content_bounds()); 1449 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1450 layer->SetTexturePriorities(priority_calculator_); 1451 resource_manager_->PrioritizeTextures(); 1452 layer->SavePaintProperties(); 1453 layer->Update(queue_.get(), &occluded); 1454 int visible_tiles2 = 6 * 6 - 3; 1455 EXPECT_EQ(visible_tiles2, layer->fake_layer_updater()->update_count()); 1456 1457 layer->fake_layer_updater()->ClearUpdateCount(); 1458 1459 // This makes sure content scaling and transforms work together. 1460 // When the tiles are scaled down by half, they are 50x50 each in the 1461 // screen. 1462 gfx::Transform screen_transform; 1463 screen_transform.Scale(0.5, 0.5); 1464 layer->draw_properties().screen_space_transform = screen_transform; 1465 layer->draw_properties().target_space_transform = screen_transform; 1466 1467 // An occlusion of 150x100 will cover 3*2 = 6 tiles. 1468 occluded.SetOcclusion(SimpleEnclosedRegion(gfx::Rect(100, 100, 150, 100))); 1469 1470 gfx::Rect layer_bounds_rect(layer->bounds()); 1471 layer->draw_properties().drawable_content_rect = 1472 gfx::ScaleToEnclosingRect(layer_bounds_rect, 0.5f); 1473 layer->draw_properties().visible_content_rect = 1474 gfx::Rect(layer->content_bounds()); 1475 layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600)); 1476 layer->SetTexturePriorities(priority_calculator_); 1477 resource_manager_->PrioritizeTextures(); 1478 layer->SavePaintProperties(); 1479 layer->Update(queue_.get(), &occluded); 1480 int visible_tiles3 = 6 * 6 - 6; 1481 EXPECT_EQ(visible_tiles3, layer->fake_layer_updater()->update_count()); 1482 } 1483 1484 TEST_F(TiledLayerTest, DontAllocateContentsWhenTargetSurfaceCantBeAllocated) { 1485 // Tile size is 100x100. 1486 gfx::Rect root_rect(0, 0, 300, 200); 1487 gfx::Rect child_rect(0, 0, 300, 100); 1488 gfx::Rect child2_rect(0, 100, 300, 100); 1489 1490 scoped_refptr<FakeTiledLayer> root = make_scoped_refptr( 1491 new FakeTiledLayer(layer_tree_host_->contents_texture_manager())); 1492 scoped_refptr<Layer> surface = Layer::Create(); 1493 scoped_refptr<FakeTiledLayer> child = make_scoped_refptr( 1494 new FakeTiledLayer(layer_tree_host_->contents_texture_manager())); 1495 scoped_refptr<FakeTiledLayer> child2 = make_scoped_refptr( 1496 new FakeTiledLayer(layer_tree_host_->contents_texture_manager())); 1497 1498 root->SetBounds(root_rect.size()); 1499 root->draw_properties().drawable_content_rect = root_rect; 1500 root->draw_properties().visible_content_rect = root_rect; 1501 root->AddChild(surface); 1502 1503 surface->SetForceRenderSurface(true); 1504 surface->SetOpacity(0.5); 1505 surface->AddChild(child); 1506 surface->AddChild(child2); 1507 1508 child->SetBounds(child_rect.size()); 1509 child->SetPosition(child_rect.origin()); 1510 child->draw_properties().visible_content_rect = child_rect; 1511 child->draw_properties().drawable_content_rect = root_rect; 1512 1513 child2->SetBounds(child2_rect.size()); 1514 child2->SetPosition(child2_rect.origin()); 1515 child2->draw_properties().visible_content_rect = child2_rect; 1516 child2->draw_properties().drawable_content_rect = root_rect; 1517 1518 layer_tree_host_->SetRootLayer(root); 1519 layer_tree_host_->SetViewportSize(root_rect.size()); 1520 1521 // With a huge memory limit, all layers should update and push their textures. 1522 root->InvalidateContentRect(root_rect); 1523 child->InvalidateContentRect(child_rect); 1524 child2->InvalidateContentRect(child2_rect); 1525 layer_tree_host_->UpdateLayers(queue_.get()); 1526 { 1527 UpdateTextures(); 1528 EXPECT_EQ(6, root->fake_layer_updater()->update_count()); 1529 EXPECT_EQ(3, child->fake_layer_updater()->update_count()); 1530 EXPECT_EQ(3, child2->fake_layer_updater()->update_count()); 1531 EXPECT_FALSE(queue_->HasMoreUpdates()); 1532 1533 root->fake_layer_updater()->ClearUpdateCount(); 1534 child->fake_layer_updater()->ClearUpdateCount(); 1535 child2->fake_layer_updater()->ClearUpdateCount(); 1536 1537 scoped_ptr<FakeTiledLayerImpl> root_impl = make_scoped_ptr( 1538 new FakeTiledLayerImpl(host_impl_->active_tree(), root->id())); 1539 scoped_ptr<FakeTiledLayerImpl> child_impl = make_scoped_ptr( 1540 new FakeTiledLayerImpl(host_impl_->active_tree(), child->id())); 1541 scoped_ptr<FakeTiledLayerImpl> child2_impl = make_scoped_ptr( 1542 new FakeTiledLayerImpl(host_impl_->active_tree(), child2->id())); 1543 LayerPushPropertiesTo(child2.get(), child2_impl.get()); 1544 LayerPushPropertiesTo(child.get(), child_impl.get()); 1545 LayerPushPropertiesTo(root.get(), root_impl.get()); 1546 1547 for (unsigned i = 0; i < 3; ++i) { 1548 for (unsigned j = 0; j < 2; ++j) 1549 EXPECT_TRUE(root_impl->HasResourceIdForTileAt(i, j)); 1550 EXPECT_TRUE(child_impl->HasResourceIdForTileAt(i, 0)); 1551 EXPECT_TRUE(child2_impl->HasResourceIdForTileAt(i, 0)); 1552 } 1553 } 1554 layer_tree_host_->CommitComplete(); 1555 1556 // With a memory limit that includes only the root layer (3x2 tiles) and half 1557 // the surface that the child layers draw into, the child layers will not be 1558 // allocated. If the surface isn't accounted for, then one of the children 1559 // would fit within the memory limit. 1560 root->InvalidateContentRect(root_rect); 1561 child->InvalidateContentRect(child_rect); 1562 child2->InvalidateContentRect(child2_rect); 1563 1564 size_t memory_limit = (3 * 2 + 3 * 1) * (100 * 100) * 4; 1565 layer_tree_host_->contents_texture_manager()->SetMaxMemoryLimitBytes( 1566 memory_limit); 1567 layer_tree_host_->UpdateLayers(queue_.get()); 1568 { 1569 UpdateTextures(); 1570 EXPECT_EQ(6, root->fake_layer_updater()->update_count()); 1571 EXPECT_EQ(0, child->fake_layer_updater()->update_count()); 1572 EXPECT_EQ(0, child2->fake_layer_updater()->update_count()); 1573 EXPECT_FALSE(queue_->HasMoreUpdates()); 1574 1575 root->fake_layer_updater()->ClearUpdateCount(); 1576 child->fake_layer_updater()->ClearUpdateCount(); 1577 child2->fake_layer_updater()->ClearUpdateCount(); 1578 1579 scoped_ptr<FakeTiledLayerImpl> root_impl = make_scoped_ptr( 1580 new FakeTiledLayerImpl(host_impl_->active_tree(), root->id())); 1581 scoped_ptr<FakeTiledLayerImpl> child_impl = make_scoped_ptr( 1582 new FakeTiledLayerImpl(host_impl_->active_tree(), child->id())); 1583 scoped_ptr<FakeTiledLayerImpl> child2_impl = make_scoped_ptr( 1584 new FakeTiledLayerImpl(host_impl_->active_tree(), child2->id())); 1585 LayerPushPropertiesTo(child2.get(), child2_impl.get()); 1586 LayerPushPropertiesTo(child.get(), child_impl.get()); 1587 LayerPushPropertiesTo(root.get(), root_impl.get()); 1588 1589 for (unsigned i = 0; i < 3; ++i) { 1590 for (unsigned j = 0; j < 2; ++j) 1591 EXPECT_TRUE(root_impl->HasResourceIdForTileAt(i, j)); 1592 EXPECT_FALSE(child_impl->HasResourceIdForTileAt(i, 0)); 1593 EXPECT_FALSE(child2_impl->HasResourceIdForTileAt(i, 0)); 1594 } 1595 } 1596 layer_tree_host_->CommitComplete(); 1597 1598 // With a memory limit that includes only half the root layer, no contents 1599 // will be allocated. If render surface memory wasn't accounted for, there is 1600 // enough space for one of the children layers, but they draw into a surface 1601 // that can't be allocated. 1602 root->InvalidateContentRect(root_rect); 1603 child->InvalidateContentRect(child_rect); 1604 child2->InvalidateContentRect(child2_rect); 1605 1606 memory_limit = (3 * 1) * (100 * 100) * 4; 1607 layer_tree_host_->contents_texture_manager()->SetMaxMemoryLimitBytes( 1608 memory_limit); 1609 layer_tree_host_->UpdateLayers(queue_.get()); 1610 { 1611 UpdateTextures(); 1612 EXPECT_EQ(0, root->fake_layer_updater()->update_count()); 1613 EXPECT_EQ(0, child->fake_layer_updater()->update_count()); 1614 EXPECT_EQ(0, child2->fake_layer_updater()->update_count()); 1615 EXPECT_FALSE(queue_->HasMoreUpdates()); 1616 1617 root->fake_layer_updater()->ClearUpdateCount(); 1618 child->fake_layer_updater()->ClearUpdateCount(); 1619 child2->fake_layer_updater()->ClearUpdateCount(); 1620 1621 scoped_ptr<FakeTiledLayerImpl> root_impl = make_scoped_ptr( 1622 new FakeTiledLayerImpl(host_impl_->active_tree(), root->id())); 1623 scoped_ptr<FakeTiledLayerImpl> child_impl = make_scoped_ptr( 1624 new FakeTiledLayerImpl(host_impl_->active_tree(), child->id())); 1625 scoped_ptr<FakeTiledLayerImpl> child2_impl = make_scoped_ptr( 1626 new FakeTiledLayerImpl(host_impl_->active_tree(), child2->id())); 1627 LayerPushPropertiesTo(child2.get(), child2_impl.get()); 1628 LayerPushPropertiesTo(child.get(), child_impl.get()); 1629 LayerPushPropertiesTo(root.get(), root_impl.get()); 1630 1631 for (unsigned i = 0; i < 3; ++i) { 1632 for (unsigned j = 0; j < 2; ++j) 1633 EXPECT_FALSE(root_impl->HasResourceIdForTileAt(i, j)); 1634 EXPECT_FALSE(child_impl->HasResourceIdForTileAt(i, 0)); 1635 EXPECT_FALSE(child2_impl->HasResourceIdForTileAt(i, 0)); 1636 } 1637 } 1638 layer_tree_host_->CommitComplete(); 1639 1640 ResourceManagerClearAllMemory(layer_tree_host_->contents_texture_manager(), 1641 resource_provider_.get()); 1642 layer_tree_host_->SetRootLayer(NULL); 1643 } 1644 1645 class TrackingLayerPainter : public LayerPainter { 1646 public: 1647 static scoped_ptr<TrackingLayerPainter> Create() { 1648 return make_scoped_ptr(new TrackingLayerPainter()); 1649 } 1650 1651 virtual void Paint(SkCanvas* canvas, const gfx::Rect& content_rect) OVERRIDE { 1652 painted_rect_ = content_rect; 1653 } 1654 1655 gfx::Rect PaintedRect() const { return painted_rect_; } 1656 void ResetPaintedRect() { painted_rect_ = gfx::Rect(); } 1657 1658 private: 1659 gfx::Rect painted_rect_; 1660 }; 1661 1662 class UpdateTrackingTiledLayer : public FakeTiledLayer { 1663 public: 1664 explicit UpdateTrackingTiledLayer(PrioritizedResourceManager* manager) 1665 : FakeTiledLayer(manager) { 1666 scoped_ptr<TrackingLayerPainter> painter(TrackingLayerPainter::Create()); 1667 tracking_layer_painter_ = painter.get(); 1668 layer_updater_ = 1669 BitmapContentLayerUpdater::Create(painter.PassAs<LayerPainter>(), 1670 &stats_instrumentation_, 1671 0); 1672 } 1673 1674 TrackingLayerPainter* tracking_layer_painter() const { 1675 return tracking_layer_painter_; 1676 } 1677 1678 private: 1679 virtual LayerUpdater* Updater() const OVERRIDE { 1680 return layer_updater_.get(); 1681 } 1682 virtual ~UpdateTrackingTiledLayer() {} 1683 1684 TrackingLayerPainter* tracking_layer_painter_; 1685 scoped_refptr<BitmapContentLayerUpdater> layer_updater_; 1686 FakeRenderingStatsInstrumentation stats_instrumentation_; 1687 }; 1688 1689 TEST_F(TiledLayerTest, NonIntegerContentsScaleIsNotDistortedDuringPaint) { 1690 scoped_refptr<UpdateTrackingTiledLayer> layer = 1691 make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get())); 1692 1693 layer_tree_host_->root_layer()->AddChild(layer); 1694 1695 gfx::Rect layer_rect(0, 0, 30, 31); 1696 layer->SetPosition(layer_rect.origin()); 1697 layer->SetBounds(layer_rect.size()); 1698 layer->UpdateContentsScale(1.5f); 1699 1700 gfx::Rect content_rect(0, 0, 45, 47); 1701 EXPECT_EQ(content_rect.size(), layer->content_bounds()); 1702 layer->draw_properties().visible_content_rect = content_rect; 1703 layer->draw_properties().drawable_content_rect = content_rect; 1704 1705 layer->SetTexturePriorities(priority_calculator_); 1706 resource_manager_->PrioritizeTextures(); 1707 layer->SavePaintProperties(); 1708 1709 // Update the whole tile. 1710 layer->Update(queue_.get(), NULL); 1711 layer->tracking_layer_painter()->ResetPaintedRect(); 1712 1713 EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect()); 1714 UpdateTextures(); 1715 1716 // Invalidate the entire layer in content space. When painting, the rect given 1717 // to webkit should match the layer's bounds. 1718 layer->InvalidateContentRect(content_rect); 1719 layer->Update(queue_.get(), NULL); 1720 1721 // Rounding leads to an extra pixel. 1722 gfx::Rect expanded_layer_rect(layer_rect); 1723 expanded_layer_rect.set_height(32); 1724 EXPECT_RECT_EQ(expanded_layer_rect, 1725 layer->tracking_layer_painter()->PaintedRect()); 1726 } 1727 1728 TEST_F(TiledLayerTest, 1729 NonIntegerContentsScaleIsNotDistortedDuringInvalidation) { 1730 scoped_refptr<UpdateTrackingTiledLayer> layer = 1731 make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get())); 1732 1733 layer_tree_host_->root_layer()->AddChild(layer); 1734 1735 gfx::Rect layer_rect(0, 0, 30, 31); 1736 layer->SetPosition(layer_rect.origin()); 1737 layer->SetBounds(layer_rect.size()); 1738 layer->UpdateContentsScale(1.3f); 1739 1740 gfx::Rect content_rect(layer->content_bounds()); 1741 layer->draw_properties().visible_content_rect = content_rect; 1742 layer->draw_properties().drawable_content_rect = content_rect; 1743 1744 layer->SetTexturePriorities(priority_calculator_); 1745 resource_manager_->PrioritizeTextures(); 1746 layer->SavePaintProperties(); 1747 1748 // Update the whole tile. 1749 layer->Update(queue_.get(), NULL); 1750 layer->tracking_layer_painter()->ResetPaintedRect(); 1751 1752 EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect()); 1753 UpdateTextures(); 1754 1755 // Invalidate the entire layer in layer space. When painting, the rect given 1756 // to webkit should match the layer's bounds. 1757 layer->SetNeedsDisplayRect(layer_rect); 1758 layer->Update(queue_.get(), NULL); 1759 1760 // Rounding leads to an extra pixel. 1761 gfx::Rect expanded_layer_rect(layer_rect); 1762 expanded_layer_rect.set_height(32); 1763 EXPECT_RECT_EQ(expanded_layer_rect, 1764 layer->tracking_layer_painter()->PaintedRect()); 1765 } 1766 1767 } // namespace 1768 } // namespace cc 1769
