cc/layers/tiled_layer_unittest.cc

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