cc/trees/layer_tree_host_unittest_picture.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/trees/layer_tree_host.h"
   6
   7 #include "cc/test/fake_content_layer_client.h"
   8 #include "cc/test/fake_picture_layer.h"
   9 #include "cc/test/fake_picture_layer_impl.h"
  10 #include "cc/test/layer_tree_test.h"
  11 #include "cc/trees/layer_tree_impl.h"
  12
  13 namespace cc {
  14 namespace {
  15
  16 // These tests deal with picture layers.
  17 class LayerTreeHostPictureTest : public LayerTreeTest {
  18  protected:
  19   void SetupTreeWithSinglePictureLayer(const gfx::Size& size) {
  20     scoped_refptr<Layer> root = Layer::Create();
  21     root->SetBounds(size);
  22
  23     root_picture_layer_ = FakePictureLayer::Create(&client_);
  24     root_picture_layer_->SetBounds(size);
  25     root->AddChild(root_picture_layer_);
  26
  27     layer_tree_host()->SetRootLayer(root);
  28   }
  29
  30   scoped_refptr<FakePictureLayer> root_picture_layer_;
  31   FakeContentLayerClient client_;
  32 };
  33
  34 class LayerTreeHostPictureTestTwinLayer
  35     : public LayerTreeHostPictureTest {
  36   void SetupTree() override {
  37     SetupTreeWithSinglePictureLayer(gfx::Size(1, 1));
  38   }
  39
  40   void BeginTest() override {
  41     activates_ = 0;
  42     PostSetNeedsCommitToMainThread();
  43   }
  44
  45   void DidCommit() override {
  46     switch (layer_tree_host()->source_frame_number()) {
  47       case 1:
  48         // Activate while there are pending and active twins in place.
  49         layer_tree_host()->SetNeedsCommit();
  50         break;
  51       case 2:
  52         // Drop the picture layer from the tree so the activate will have an
  53         // active layer without a pending twin.
  54         layer_tree_host()->root_layer()->children()[0]->RemoveFromParent();
  55         break;
  56       case 3: {
  57         // Add a new picture layer so the activate will have a pending layer
  58         // without an active twin.
  59         scoped_refptr<FakePictureLayer> picture =
  60             FakePictureLayer::Create(&client_);
  61         layer_tree_host()->root_layer()->AddChild(picture);
  62         break;
  63       }
  64       case 4:
  65         // Active while there are pending and active twins again.
  66         layer_tree_host()->SetNeedsCommit();
  67         break;
  68       case 5:
  69         EndTest();
  70         break;
  71     }
  72   }
  73
  74   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
  75     LayerImpl* pending_root_impl = impl->pending_tree()->root_layer();
  76     LayerImpl* active_root_impl = impl->active_tree()->root_layer();
  77
  78     if (pending_root_impl->children().empty()) {
  79       EXPECT_EQ(2, activates_);
  80       return;
  81     }
  82
  83     FakePictureLayerImpl* pending_picture_impl =
  84         static_cast<FakePictureLayerImpl*>(pending_root_impl->children()[0]);
  85
  86     if (!active_root_impl) {
  87       EXPECT_EQ(0, activates_);
  88       EXPECT_EQ(nullptr, pending_picture_impl->GetPendingOrActiveTwinLayer());
  89       return;
  90     }
  91
  92     if (active_root_impl->children().empty()) {
  93       EXPECT_EQ(3, activates_);
  94       EXPECT_EQ(nullptr, pending_picture_impl->GetPendingOrActiveTwinLayer());
  95       return;
  96     }
  97
  98     FakePictureLayerImpl* active_picture_impl =
  99         static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
 100
 101     // After the first activation, when we commit again, we'll have a pending
 102     // and active layer. Then we recreate a picture layer in the 4th activate
 103     // and the next commit will have a pending and active twin again.
 104     EXPECT_TRUE(activates_ == 1 || activates_ == 4) << activates_;
 105
 106     EXPECT_EQ(pending_picture_impl,
 107               active_picture_impl->GetPendingOrActiveTwinLayer());
 108     EXPECT_EQ(active_picture_impl,
 109               pending_picture_impl->GetPendingOrActiveTwinLayer());
 110     EXPECT_EQ(nullptr, active_picture_impl->GetRecycledTwinLayer());
 111   }
 112
 113   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
 114     LayerImpl* active_root_impl = impl->active_tree()->root_layer();
 115     LayerImpl* recycle_root_impl = impl->recycle_tree()->root_layer();
 116
 117     if (active_root_impl->children().empty()) {
 118       EXPECT_EQ(2, activates_);
 119     } else {
 120       FakePictureLayerImpl* active_picture_impl =
 121           static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
 122       FakePictureLayerImpl* recycle_picture_impl =
 123           static_cast<FakePictureLayerImpl*>(recycle_root_impl->children()[0]);
 124
 125       EXPECT_EQ(nullptr, active_picture_impl->GetPendingOrActiveTwinLayer());
 126       EXPECT_EQ(recycle_picture_impl,
 127                 active_picture_impl->GetRecycledTwinLayer());
 128     }
 129
 130     ++activates_;
 131   }
 132
 133   void AfterTest() override { EXPECT_EQ(5, activates_); }
 134
 135   int activates_;
 136 };
 137
 138 // There is no pending layers in single thread mode.
 139 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostPictureTestTwinLayer);
 140
 141 class LayerTreeHostPictureTestResizeViewportWithGpuRaster
 142     : public LayerTreeHostPictureTest {
 143   void InitializeSettings(LayerTreeSettings* settings) override {
 144     settings->gpu_rasterization_forced = true;
 145   }
 146
 147   void SetupTree() override {
 148     scoped_refptr<Layer> root = Layer::Create();
 149     root->SetBounds(gfx::Size(768, 960));
 150
 151     client_.set_fill_with_nonsolid_color(true);
 152     picture_ = FakePictureLayer::Create(&client_);
 153     picture_->SetBounds(gfx::Size(768, 960));
 154     root->AddChild(picture_);
 155
 156     layer_tree_host()->SetRootLayer(root);
 157     LayerTreeHostPictureTest::SetupTree();
 158   }
 159
 160   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 161
 162   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
 163     LayerImpl* child = impl->sync_tree()->root_layer()->children()[0];
 164     FakePictureLayerImpl* picture_impl =
 165         static_cast<FakePictureLayerImpl*>(child);
 166     gfx::Size tile_size =
 167         picture_impl->HighResTiling()->TileAt(0, 0)->content_rect().size();
 168
 169     switch (impl->sync_tree()->source_frame_number()) {
 170       case 0:
 171         tile_size_ = tile_size;
 172         // GPU Raster picks a tile size based on the viewport size.
 173         EXPECT_EQ(gfx::Size(768, 256), tile_size);
 174         break;
 175       case 1:
 176         // When the viewport changed size, the new frame's tiles should change
 177         // along with it.
 178         EXPECT_NE(gfx::Size(768, 256), tile_size);
 179     }
 180   }
 181
 182   void DidCommit() override {
 183     switch (layer_tree_host()->source_frame_number()) {
 184       case 1:
 185         // Change the picture layer's size along with the viewport, so it will
 186         // consider picking a new tile size.
 187         picture_->SetBounds(gfx::Size(768, 1056));
 188         layer_tree_host()->SetViewportSize(gfx::Size(768, 1056));
 189         break;
 190       case 2:
 191         EndTest();
 192     }
 193   }
 194
 195   void AfterTest() override {}
 196
 197   gfx::Size tile_size_;
 198   FakeContentLayerClient client_;
 199   scoped_refptr<FakePictureLayer> picture_;
 200 };
 201
 202 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(
 203     LayerTreeHostPictureTestResizeViewportWithGpuRaster);
 204
 205 class LayerTreeHostPictureTestChangeLiveTilesRectWithRecycleTree
 206     : public LayerTreeHostPictureTest {
 207   void SetupTree() override {
 208     frame_ = 0;
 209     did_post_commit_ = false;
 210
 211     scoped_refptr<Layer> root = Layer::Create();
 212     root->SetBounds(gfx::Size(100, 100));
 213
 214     // The layer is big enough that the live tiles rect won't cover the full
 215     // layer.
 216     client_.set_fill_with_nonsolid_color(true);
 217     picture_ = FakePictureLayer::Create(&client_);
 218     picture_->SetBounds(gfx::Size(100, 100000));
 219     root->AddChild(picture_);
 220
 221     layer_tree_host()->SetRootLayer(root);
 222     LayerTreeHostPictureTest::SetupTree();
 223   }
 224
 225   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 226
 227   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
 228     LayerImpl* child = impl->active_tree()->root_layer()->children()[0];
 229     FakePictureLayerImpl* picture_impl =
 230         static_cast<FakePictureLayerImpl*>(child);
 231     FakePictureLayerImpl* recycled_impl = static_cast<FakePictureLayerImpl*>(
 232         picture_impl->GetRecycledTwinLayer());
 233
 234     switch (++frame_) {
 235       case 1: {
 236         PictureLayerTiling* tiling = picture_impl->HighResTiling();
 237         PictureLayerTiling* recycled_tiling = recycled_impl->HighResTiling();
 238         int num_tiles_y = tiling->TilingDataForTesting().num_tiles_y();
 239
 240         // There should be tiles at the top of the picture layer but not at the
 241         // bottom.
 242         EXPECT_TRUE(tiling->TileAt(0, 0));
 243         EXPECT_FALSE(tiling->TileAt(0, num_tiles_y));
 244
 245         // The recycled tiling matches it.
 246         EXPECT_TRUE(recycled_tiling->TileAt(0, 0));
 247         EXPECT_FALSE(recycled_tiling->TileAt(0, num_tiles_y));
 248
 249         // The live tiles rect matches on the recycled tree.
 250         EXPECT_EQ(tiling->live_tiles_rect(),
 251                   recycled_tiling->live_tiles_rect());
 252
 253         // Make the bottom of the layer visible.
 254         picture_impl->SetPosition(gfx::PointF(0.f, -100000.f + 100.f));
 255         impl->SetNeedsRedraw();
 256         break;
 257       }
 258       case 2: {
 259         PictureLayerTiling* tiling = picture_impl->HighResTiling();
 260         PictureLayerTiling* recycled_tiling = recycled_impl->HighResTiling();
 261
 262         // There not be tiles at the top of the layer now.
 263         EXPECT_FALSE(tiling->TileAt(0, 0));
 264
 265         // The recycled twin tiling should not have unshared tiles at the top
 266         // either.
 267         EXPECT_FALSE(recycled_tiling->TileAt(0, 0));
 268
 269         // The live tiles rect matches on the recycled tree.
 270         EXPECT_EQ(tiling->live_tiles_rect(),
 271                   recycled_tiling->live_tiles_rect());
 272
 273         // Make the top of the layer visible again.
 274         picture_impl->SetPosition(gfx::PointF());
 275         impl->SetNeedsRedraw();
 276         break;
 277       }
 278       case 3: {
 279         PictureLayerTiling* tiling = picture_impl->HighResTiling();
 280         PictureLayerTiling* recycled_tiling = recycled_impl->HighResTiling();
 281         int num_tiles_y = tiling->TilingDataForTesting().num_tiles_y();
 282
 283         // There should be tiles at the top of the picture layer again.
 284         EXPECT_TRUE(tiling->TileAt(0, 0));
 285         EXPECT_FALSE(tiling->TileAt(0, num_tiles_y));
 286
 287         // The recycled tiling should also have tiles at the top.
 288         EXPECT_TRUE(recycled_tiling->TileAt(0, 0));
 289         EXPECT_FALSE(recycled_tiling->TileAt(0, num_tiles_y));
 290
 291         // The live tiles rect matches on the recycled tree.
 292         EXPECT_EQ(tiling->live_tiles_rect(),
 293                   recycled_tiling->live_tiles_rect());
 294
 295         // Make a new main frame without changing the picture layer at all, so
 296         // it won't need to update or push properties.
 297         did_post_commit_ = true;
 298         PostSetNeedsCommitToMainThread();
 299         break;
 300       }
 301     }
 302   }
 303
 304   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
 305     LayerImpl* child = impl->sync_tree()->root_layer()->children()[0];
 306     FakePictureLayerImpl* picture_impl =
 307         static_cast<FakePictureLayerImpl*>(child);
 308     PictureLayerTiling* tiling = picture_impl->HighResTiling();
 309     int num_tiles_y = tiling->TilingDataForTesting().num_tiles_y();
 310
 311     // The pending layer should always have tiles at the top of it each commit.
 312     // The tile is part of the required for activation set so it should exist.
 313     EXPECT_TRUE(tiling->TileAt(0, 0));
 314     EXPECT_FALSE(tiling->TileAt(0, num_tiles_y));
 315
 316     if (did_post_commit_)
 317       EndTest();
 318   }
 319
 320   void AfterTest() override {}
 321
 322   int frame_;
 323   bool did_post_commit_;
 324   FakeContentLayerClient client_;
 325   scoped_refptr<FakePictureLayer> picture_;
 326 };
 327
 328 // Multi-thread only since there is no recycle tree in single thread.
 329 MULTI_THREAD_IMPL_TEST_F(
 330     LayerTreeHostPictureTestChangeLiveTilesRectWithRecycleTree);
 331
 332 class LayerTreeHostPictureTestRSLLMembership : public LayerTreeHostPictureTest {
 333   void SetupTree() override {
 334     scoped_refptr<Layer> root = Layer::Create();
 335     root->SetBounds(gfx::Size(100, 100));
 336
 337     child_ = Layer::Create();
 338     root->AddChild(child_);
 339
 340     // Don't be solid color so the layer has tilings/tiles.
 341     client_.set_fill_with_nonsolid_color(true);
 342     picture_ = FakePictureLayer::Create(&client_);
 343     picture_->SetBounds(gfx::Size(100, 100));
 344     child_->AddChild(picture_);
 345
 346     layer_tree_host()->SetRootLayer(root);
 347     LayerTreeHostPictureTest::SetupTree();
 348   }
 349
 350   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 351
 352   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
 353     LayerImpl* root = impl->sync_tree()->root_layer();
 354     LayerImpl* child = root->children()[0];
 355     LayerImpl* gchild = child->children()[0];
 356     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 357
 358     switch (impl->sync_tree()->source_frame_number()) {
 359       case 0:
 360         // On 1st commit the layer has tilings.
 361         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 362         break;
 363       case 1:
 364         // On 2nd commit, the layer is transparent, but its tilings are left
 365         // there.
 366         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 367         break;
 368       case 2:
 369         // On 3rd commit, the layer is visible again, so has tilings.
 370         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 371     }
 372   }
 373
 374   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
 375     LayerImpl* root = impl->active_tree()->root_layer();
 376     LayerImpl* child = root->children()[0];
 377     LayerImpl* gchild = child->children()[0];
 378     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 379
 380     switch (impl->active_tree()->source_frame_number()) {
 381       case 0:
 382         // On 1st commit the layer has tilings.
 383         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 384         break;
 385       case 1:
 386         // On 2nd commit, the layer is transparent, but its tilings are left
 387         // there.
 388         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 389         break;
 390       case 2:
 391         // On 3rd commit, the layer is visible again, so has tilings.
 392         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 393         EndTest();
 394     }
 395   }
 396
 397   void DidCommit() override {
 398     switch (layer_tree_host()->source_frame_number()) {
 399       case 1:
 400         // For the 2nd commit, change opacity to 0 so that the layer will not be
 401         // part of the visible frame.
 402         child_->SetOpacity(0.f);
 403         break;
 404       case 2:
 405         // For the 3rd commit, change opacity to 1 so that the layer will again
 406         // be part of the visible frame.
 407         child_->SetOpacity(1.f);
 408     }
 409   }
 410
 411   void AfterTest() override {}
 412
 413   FakeContentLayerClient client_;
 414   scoped_refptr<Layer> child_;
 415   scoped_refptr<FakePictureLayer> picture_;
 416 };
 417
 418 SINGLE_AND_MULTI_THREAD_IMPL_TEST_F(LayerTreeHostPictureTestRSLLMembership);
 419
 420 class LayerTreeHostPictureTestRSLLMembershipWithScale
 421     : public LayerTreeHostPictureTest {
 422   void SetupTree() override {
 423     scoped_refptr<Layer> root = Layer::Create();
 424     root->SetBounds(gfx::Size(100, 100));
 425
 426     pinch_ = Layer::Create();
 427     pinch_->SetBounds(gfx::Size(500, 500));
 428     pinch_->SetScrollClipLayerId(root->id());
 429     pinch_->SetIsContainerForFixedPositionLayers(true);
 430     root->AddChild(pinch_);
 431
 432     // Don't be solid color so the layer has tilings/tiles.
 433     client_.set_fill_with_nonsolid_color(true);
 434     picture_ = FakePictureLayer::Create(&client_);
 435     picture_->SetBounds(gfx::Size(100, 100));
 436     pinch_->AddChild(picture_);
 437
 438     layer_tree_host()->RegisterViewportLayers(NULL, root, pinch_, pinch_);
 439     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 1.f, 4.f);
 440     layer_tree_host()->SetRootLayer(root);
 441     LayerTreeHostPictureTest::SetupTree();
 442   }
 443
 444   void InitializeSettings(LayerTreeSettings* settings) override {
 445     settings->layer_transforms_should_scale_layer_contents = true;
 446   }
 447
 448   void BeginTest() override {
 449     frame_ = 0;
 450     draws_in_frame_ = 0;
 451     last_frame_drawn_ = -1;
 452     PostSetNeedsCommitToMainThread();
 453   }
 454
 455   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
 456     LayerImpl* root = impl->sync_tree()->root_layer();
 457     LayerImpl* pinch = root->children()[0];
 458     LayerImpl* gchild = pinch->children()[0];
 459     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 460
 461     switch (frame_) {
 462       case 0:
 463         // On 1st commit the layer has tilings.
 464         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 465         break;
 466       case 1:
 467         // On 2nd commit, the layer is transparent, so does not have tilings.
 468         EXPECT_EQ(0u, picture->tilings()->num_tilings());
 469         break;
 470       case 2:
 471         // On 3rd commit, the layer is visible again, so has tilings.
 472         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 473     }
 474   }
 475
 476   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
 477     LayerImpl* root = impl->active_tree()->root_layer();
 478     LayerImpl* pinch = root->children()[0];
 479     LayerImpl* gchild = pinch->children()[0];
 480     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 481
 482     if (frame_ != last_frame_drawn_)
 483       draws_in_frame_ = 0;
 484     ++draws_in_frame_;
 485     last_frame_drawn_ = frame_;
 486
 487     switch (frame_) {
 488       case 0:
 489         if (draws_in_frame_ == 1) {
 490           // On 1st commit the layer has tilings.
 491           EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 492           EXPECT_EQ(1.f, picture->HighResTiling()->contents_scale());
 493
 494           // Pinch zoom in to change the scale on the active tree.
 495           impl->PinchGestureBegin();
 496           impl->PinchGestureUpdate(2.f, gfx::Point(1, 1));
 497           impl->PinchGestureEnd();
 498         } else if (picture->tilings()->num_tilings() == 1) {
 499           // If the pinch gesture caused a commit we could get here with a
 500           // pending tree.
 501           EXPECT_FALSE(impl->pending_tree());
 502           // The active layer now has only a 2.f scale tiling, which means the
 503           // recycled layer's tiling is destroyed.
 504           EXPECT_EQ(2.f, picture->HighResTiling()->contents_scale());
 505           EXPECT_EQ(0u, picture->GetRecycledTwinLayer()
 506                             ->picture_layer_tiling_set()
 507                             ->num_tilings());
 508
 509           ++frame_;
 510           MainThreadTaskRunner()->PostTask(
 511               FROM_HERE,
 512               base::Bind(
 513                   &LayerTreeHostPictureTestRSLLMembershipWithScale::NextStep,
 514                   base::Unretained(this)));
 515         }
 516         break;
 517       case 1:
 518         EXPECT_EQ(1, draws_in_frame_);
 519         // On 2nd commit, the layer is transparent, so does not create
 520         // tilings. Since the 1.f tiling was destroyed in the recycle tree, it
 521         // has no tilings left. This is propogated to the active tree.
 522         EXPECT_EQ(0u, picture->picture_layer_tiling_set()->num_tilings());
 523         EXPECT_EQ(0u, picture->GetRecycledTwinLayer()
 524                           ->picture_layer_tiling_set()
 525                           ->num_tilings());
 526         ++frame_;
 527         MainThreadTaskRunner()->PostTask(
 528             FROM_HERE,
 529             base::Bind(
 530                 &LayerTreeHostPictureTestRSLLMembershipWithScale::NextStep,
 531                 base::Unretained(this)));
 532         break;
 533       case 2:
 534         EXPECT_EQ(1, draws_in_frame_);
 535         // On 3rd commit, the layer is visible again, so has tilings.
 536         EXPECT_GT(picture->tilings()->num_tilings(), 0u);
 537         EndTest();
 538     }
 539   }
 540
 541   void NextStep() {
 542     switch (frame_) {
 543       case 1:
 544         // For the 2nd commit, change opacity to 0 so that the layer will not be
 545         // part of the visible frame.
 546         pinch_->SetOpacity(0.f);
 547         break;
 548       case 2:
 549         // For the 3rd commit, change opacity to 1 so that the layer will again
 550         // be part of the visible frame.
 551         pinch_->SetOpacity(1.f);
 552         break;
 553     }
 554   }
 555
 556   void AfterTest() override {}
 557
 558   FakeContentLayerClient client_;
 559   scoped_refptr<Layer> pinch_;
 560   scoped_refptr<FakePictureLayer> picture_;
 561   int frame_;
 562   int draws_in_frame_;
 563   int last_frame_drawn_;
 564 };
 565
 566 // Multi-thread only because in single thread you can't pinch zoom on the
 567 // compositor thread.
 568 MULTI_THREAD_IMPL_TEST_F(LayerTreeHostPictureTestRSLLMembershipWithScale);
 569
 570 }  // namespace
 571 }  // namespace cc