src/cc/layers/picture_layer_impl_unittest.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/layers/picture_layer_impl.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <set>
  10 #include <utility>
  11
  12 #include "cc/base/math_util.h"
  13 #include "cc/layers/append_quads_data.h"
  14 #include "cc/layers/picture_layer.h"
  15 #include "cc/quads/draw_quad.h"
  16 #include "cc/test/fake_content_layer_client.h"
  17 #include "cc/test/fake_impl_proxy.h"
  18 #include "cc/test/fake_layer_tree_host_impl.h"
  19 #include "cc/test/fake_output_surface.h"
  20 #include "cc/test/fake_picture_layer_impl.h"
  21 #include "cc/test/fake_picture_pile_impl.h"
  22 #include "cc/test/geometry_test_utils.h"
  23 #include "cc/test/impl_side_painting_settings.h"
  24 #include "cc/test/layer_test_common.h"
  25 #include "cc/test/test_shared_bitmap_manager.h"
  26 #include "cc/test/test_web_graphics_context_3d.h"
  27 #include "cc/trees/layer_tree_impl.h"
  28 #include "testing/gtest/include/gtest/gtest.h"
  29 #include "ui/gfx/rect_conversions.h"
  30 #include "ui/gfx/size_conversions.h"
  31
  32 namespace cc {
  33 namespace {
  34
  35 class MockCanvas : public SkCanvas {
  36  public:
  37   explicit MockCanvas(int w, int h) : SkCanvas(w, h) {}
  38
  39   virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE {
  40     // Capture calls before SkCanvas quickReject() kicks in.
  41     rects_.push_back(rect);
  42   }
  43
  44   std::vector<SkRect> rects_;
  45 };
  46
  47 class PictureLayerImplTest : public testing::Test {
  48  public:
  49   PictureLayerImplTest()
  50       : proxy_(base::MessageLoopProxy::current()),
  51         host_impl_(ImplSidePaintingSettings(),
  52                    &proxy_,
  53                    &shared_bitmap_manager_),
  54         id_(7) {}
  55
  56   explicit PictureLayerImplTest(const LayerTreeSettings& settings)
  57       : proxy_(base::MessageLoopProxy::current()),
  58         host_impl_(settings, &proxy_, &shared_bitmap_manager_),
  59         id_(7) {}
  60
  61   virtual ~PictureLayerImplTest() {
  62   }
  63
  64   virtual void SetUp() OVERRIDE {
  65     InitializeRenderer();
  66   }
  67
  68   virtual void InitializeRenderer() {
  69     host_impl_.InitializeRenderer(
  70         FakeOutputSurface::Create3d().PassAs<OutputSurface>());
  71   }
  72
  73   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
  74     gfx::Size tile_size(100, 100);
  75
  76     scoped_refptr<FakePicturePileImpl> pending_pile =
  77         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
  78     scoped_refptr<FakePicturePileImpl> active_pile =
  79         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
  80
  81     SetupTrees(pending_pile, active_pile);
  82   }
  83
  84   void ActivateTree() {
  85     host_impl_.ActivateSyncTree();
  86     CHECK(!host_impl_.pending_tree());
  87     pending_layer_ = NULL;
  88     active_layer_ = static_cast<FakePictureLayerImpl*>(
  89         host_impl_.active_tree()->LayerById(id_));
  90   }
  91
  92   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
  93                                           const gfx::Size& tile_size) {
  94     SetupDefaultTrees(layer_bounds);
  95     pending_layer_->set_fixed_tile_size(tile_size);
  96     active_layer_->set_fixed_tile_size(tile_size);
  97   }
  98
  99   void SetupTrees(
 100       scoped_refptr<PicturePileImpl> pending_pile,
 101       scoped_refptr<PicturePileImpl> active_pile) {
 102     SetupPendingTree(active_pile);
 103     ActivateTree();
 104     SetupPendingTree(pending_pile);
 105     host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.f, 0.25f, 100.f);
 106     host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.f, 0.25f, 100.f);
 107   }
 108
 109   void CreateHighLowResAndSetAllTilesVisible() {
 110     // Active layer must get updated first so pending layer can share from it.
 111     active_layer_->CreateDefaultTilingsAndTiles();
 112     active_layer_->SetAllTilesVisible();
 113     pending_layer_->CreateDefaultTilingsAndTiles();
 114     pending_layer_->SetAllTilesVisible();
 115   }
 116
 117   void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
 118     active_layer_->AddTiling(2.3f);
 119     active_layer_->AddTiling(1.0f);
 120     active_layer_->AddTiling(0.5f);
 121     for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i)
 122       active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
 123     pending_layer_->set_invalidation(invalidation);
 124     for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i)
 125       pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
 126   }
 127
 128   void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
 129     host_impl_.CreatePendingTree();
 130     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 131     // Clear recycled tree.
 132     pending_tree->DetachLayerTree();
 133
 134     scoped_ptr<FakePictureLayerImpl> pending_layer =
 135         FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
 136     pending_layer->SetDrawsContent(true);
 137     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 138
 139     pending_layer_ = static_cast<FakePictureLayerImpl*>(
 140         host_impl_.pending_tree()->LayerById(id_));
 141     pending_layer_->DoPostCommitInitializationIfNeeded();
 142   }
 143
 144   void SetupDrawPropertiesAndUpdateTiles(FakePictureLayerImpl* layer,
 145                                          float ideal_contents_scale,
 146                                          float device_scale_factor,
 147                                          float page_scale_factor,
 148                                          float maximum_animation_contents_scale,
 149                                          bool animating_transform_to_screen) {
 150     layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
 151     layer->draw_properties().device_scale_factor = device_scale_factor;
 152     layer->draw_properties().page_scale_factor = page_scale_factor;
 153     layer->draw_properties().maximum_animation_contents_scale =
 154         maximum_animation_contents_scale;
 155     layer->draw_properties().screen_space_transform_is_animating =
 156         animating_transform_to_screen;
 157     layer->UpdateTiles(NULL);
 158   }
 159   static void VerifyAllTilesExistAndHavePile(
 160       const PictureLayerTiling* tiling,
 161       PicturePileImpl* pile) {
 162     for (PictureLayerTiling::CoverageIterator iter(
 163              tiling,
 164              tiling->contents_scale(),
 165              gfx::Rect(tiling->tiling_size()));
 166          iter;
 167          ++iter) {
 168       EXPECT_TRUE(*iter);
 169       EXPECT_EQ(pile, iter->picture_pile());
 170     }
 171   }
 172
 173   void SetContentsScaleOnBothLayers(float contents_scale,
 174                                     float device_scale_factor,
 175                                     float page_scale_factor,
 176                                     float maximum_animation_contents_scale,
 177                                     bool animating_transform) {
 178     SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 179                                       contents_scale,
 180                                       device_scale_factor,
 181                                       page_scale_factor,
 182                                       maximum_animation_contents_scale,
 183                                       animating_transform);
 184
 185     SetupDrawPropertiesAndUpdateTiles(active_layer_,
 186                                       contents_scale,
 187                                       device_scale_factor,
 188                                       page_scale_factor,
 189                                       maximum_animation_contents_scale,
 190                                       animating_transform);
 191   }
 192
 193   void ResetTilingsAndRasterScales() {
 194     pending_layer_->ReleaseResources();
 195     active_layer_->ReleaseResources();
 196   }
 197
 198   void AssertAllTilesRequired(PictureLayerTiling* tiling) {
 199     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 200     for (size_t i = 0; i < tiles.size(); ++i)
 201       EXPECT_TRUE(tiles[i]->required_for_activation()) << "i: " << i;
 202     EXPECT_GT(tiles.size(), 0u);
 203   }
 204
 205   void AssertNoTilesRequired(PictureLayerTiling* tiling) {
 206     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 207     for (size_t i = 0; i < tiles.size(); ++i)
 208       EXPECT_FALSE(tiles[i]->required_for_activation()) << "i: " << i;
 209     EXPECT_GT(tiles.size(), 0u);
 210   }
 211
 212  protected:
 213   void TestTileGridAlignmentCommon() {
 214     // Layer to span 4 raster tiles in x and in y
 215     ImplSidePaintingSettings settings;
 216     gfx::Size layer_size(
 217         settings.default_tile_size.width() * 7 / 2,
 218         settings.default_tile_size.height() * 7 / 2);
 219
 220     scoped_refptr<FakePicturePileImpl> pending_pile =
 221         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 222     scoped_refptr<FakePicturePileImpl> active_pile =
 223         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 224
 225     SetupTrees(pending_pile, active_pile);
 226
 227     SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 228
 229     // Add 1x1 rects at the centers of each tile, then re-record pile contents
 230     active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 231     std::vector<Tile*> tiles =
 232         active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
 233     EXPECT_EQ(16u, tiles.size());
 234     std::vector<SkRect> rects;
 235     std::vector<Tile*>::const_iterator tile_iter;
 236     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
 237       gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
 238       gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
 239       active_pile->add_draw_rect(rect);
 240       rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
 241     }
 242     // Force re-record with newly injected content
 243     active_pile->RemoveRecordingAt(0, 0);
 244     active_pile->AddRecordingAt(0, 0);
 245
 246     std::vector<SkRect>::const_iterator rect_iter = rects.begin();
 247     for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
 248       MockCanvas mock_canvas(1000, 1000);
 249       active_pile->RasterDirect(
 250           &mock_canvas, (*tile_iter)->content_rect(), 1.0f, NULL);
 251
 252       // This test verifies that when drawing the contents of a specific tile
 253       // at content scale 1.0, the playback canvas never receives content from
 254       // neighboring tiles which indicates that the tile grid embedded in
 255       // SkPicture is perfectly aligned with the compositor's tiles.
 256       EXPECT_EQ(1u, mock_canvas.rects_.size());
 257       EXPECT_RECT_EQ(*rect_iter, mock_canvas.rects_[0]);
 258       rect_iter++;
 259     }
 260   }
 261
 262   FakeImplProxy proxy_;
 263   TestSharedBitmapManager shared_bitmap_manager_;
 264   FakeLayerTreeHostImpl host_impl_;
 265   int id_;
 266   FakePictureLayerImpl* pending_layer_;
 267   FakePictureLayerImpl* active_layer_;
 268
 269  private:
 270   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 271 };
 272
 273 TEST_F(PictureLayerImplTest, TileGridAlignment) {
 274   host_impl_.SetDeviceScaleFactor(1.f);
 275   TestTileGridAlignmentCommon();
 276 }
 277
 278 TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) {
 279   host_impl_.SetDeviceScaleFactor(2.f);
 280   TestTileGridAlignmentCommon();
 281 }
 282
 283 TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
 284   gfx::Size tile_size(100, 100);
 285   gfx::Size layer_bounds(400, 400);
 286
 287   scoped_refptr<FakePicturePileImpl> pending_pile =
 288       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 289   scoped_refptr<FakePicturePileImpl> active_pile =
 290       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 291
 292   SetupTrees(pending_pile, active_pile);
 293
 294   Region invalidation;
 295   AddDefaultTilingsWithInvalidation(invalidation);
 296
 297   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
 298             active_layer_->tilings()->num_tilings());
 299
 300   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
 301   EXPECT_GT(tilings->num_tilings(), 0u);
 302   for (size_t i = 0; i < tilings->num_tilings(); ++i)
 303     VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), active_pile.get());
 304 }
 305
 306 TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
 307   base::TimeTicks time_ticks;
 308   time_ticks += base::TimeDelta::FromMilliseconds(1);
 309   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 310   gfx::Size tile_size(100, 100);
 311   gfx::Size layer_bounds(400, 400);
 312
 313   scoped_refptr<FakePicturePileImpl> pending_pile =
 314       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 315   scoped_refptr<FakePicturePileImpl> active_pile =
 316       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 317
 318   SetupTrees(pending_pile, active_pile);
 319
 320   Region invalidation;
 321   AddDefaultTilingsWithInvalidation(invalidation);
 322   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 323
 324   time_ticks += base::TimeDelta::FromMilliseconds(200);
 325   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 326
 327   // Update tiles with viewport for tile priority as (0, 0, 100, 100) and the
 328   // identify transform for tile priority.
 329   bool resourceless_software_draw = false;
 330   gfx::Rect viewport = gfx::Rect(layer_bounds),
 331             viewport_rect_for_tile_priority = gfx::Rect(0, 0, 100, 100);
 332   gfx::Transform transform, transform_for_tile_priority;
 333
 334   host_impl_.SetExternalDrawConstraints(transform,
 335                                         viewport,
 336                                         viewport,
 337                                         viewport_rect_for_tile_priority,
 338                                         transform_for_tile_priority,
 339                                         resourceless_software_draw);
 340   active_layer_->draw_properties().visible_content_rect = viewport;
 341   active_layer_->draw_properties().screen_space_transform = transform;
 342   active_layer_->UpdateTiles(NULL);
 343
 344   gfx::Rect viewport_rect_for_tile_priority_in_view_space =
 345       viewport_rect_for_tile_priority;
 346
 347   // Verify the viewport rect for tile priority is used in picture layer impl.
 348   EXPECT_EQ(active_layer_->viewport_rect_for_tile_priority(),
 349             viewport_rect_for_tile_priority_in_view_space);
 350
 351   // Verify the viewport rect for tile priority is used in picture layer tiling.
 352   PictureLayerTilingSet* tilings = active_layer_->tilings();
 353   for (size_t i = 0; i < tilings->num_tilings(); i++) {
 354     PictureLayerTiling* tiling = tilings->tiling_at(i);
 355     EXPECT_EQ(
 356         tiling->GetCurrentVisibleRectForTesting(),
 357         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
 358                                   tiling->contents_scale()));
 359   }
 360
 361   // Update tiles with viewport for tile priority as (200, 200, 100, 100) in
 362   // screen space and the transform for tile priority is translated and
 363   // rotated. The actual viewport for tile priority used by PictureLayerImpl
 364   // should be (200, 200, 100, 100) applied with the said transform.
 365   time_ticks += base::TimeDelta::FromMilliseconds(200);
 366   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 367
 368   viewport_rect_for_tile_priority = gfx::Rect(200, 200, 100, 100);
 369   transform_for_tile_priority.Translate(100, 100);
 370   transform_for_tile_priority.Rotate(45);
 371   host_impl_.SetExternalDrawConstraints(transform,
 372                                         viewport,
 373                                         viewport,
 374                                         viewport_rect_for_tile_priority,
 375                                         transform_for_tile_priority,
 376                                         resourceless_software_draw);
 377   active_layer_->draw_properties().visible_content_rect = viewport;
 378   active_layer_->draw_properties().screen_space_transform = transform;
 379   active_layer_->UpdateTiles(NULL);
 380
 381   gfx::Transform screen_to_view(gfx::Transform::kSkipInitialization);
 382   bool success = transform_for_tile_priority.GetInverse(&screen_to_view);
 383   EXPECT_TRUE(success);
 384
 385   viewport_rect_for_tile_priority_in_view_space =
 386       gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
 387           screen_to_view, viewport_rect_for_tile_priority));
 388
 389   // Verify the viewport rect for tile priority is used in PictureLayerImpl.
 390   EXPECT_EQ(active_layer_->viewport_rect_for_tile_priority(),
 391             viewport_rect_for_tile_priority_in_view_space);
 392
 393   // Interset viewport_rect_for_tile_priority_in_view_space with the layer
 394   // bounds and the result should be used in PictureLayerTiling.
 395   viewport_rect_for_tile_priority_in_view_space.Intersect(
 396       gfx::Rect(layer_bounds));
 397   tilings = active_layer_->tilings();
 398   for (size_t i = 0; i < tilings->num_tilings(); i++) {
 399     PictureLayerTiling* tiling = tilings->tiling_at(i);
 400     EXPECT_EQ(
 401         tiling->GetCurrentVisibleRectForTesting(),
 402         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
 403                                   tiling->contents_scale()));
 404   }
 405 }
 406
 407 TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
 408   base::TimeTicks time_ticks;
 409   time_ticks += base::TimeDelta::FromMilliseconds(1);
 410   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 411
 412   gfx::Size tile_size(100, 100);
 413   gfx::Size layer_bounds(400, 400);
 414
 415   scoped_refptr<FakePicturePileImpl> pending_pile =
 416       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 417   scoped_refptr<FakePicturePileImpl> active_pile =
 418       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 419
 420   SetupTrees(pending_pile, active_pile);
 421
 422   Region invalidation;
 423   AddDefaultTilingsWithInvalidation(invalidation);
 424   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 425
 426   // UpdateTiles with valid viewport. Should update tile viewport.
 427   // Note viewport is considered invalid if and only if in resourceless
 428   // software draw.
 429   bool resourceless_software_draw = false;
 430   gfx::Rect viewport = gfx::Rect(layer_bounds);
 431   gfx::Transform transform;
 432   host_impl_.SetExternalDrawConstraints(transform,
 433                                         viewport,
 434                                         viewport,
 435                                         viewport,
 436                                         transform,
 437                                         resourceless_software_draw);
 438   active_layer_->draw_properties().visible_content_rect = viewport;
 439   active_layer_->draw_properties().screen_space_transform = transform;
 440   active_layer_->UpdateTiles(NULL);
 441
 442   gfx::Rect visible_rect_for_tile_priority =
 443       active_layer_->visible_rect_for_tile_priority();
 444   EXPECT_FALSE(visible_rect_for_tile_priority.IsEmpty());
 445   gfx::Rect viewport_rect_for_tile_priority =
 446       active_layer_->viewport_rect_for_tile_priority();
 447   EXPECT_FALSE(viewport_rect_for_tile_priority.IsEmpty());
 448   gfx::Transform screen_space_transform_for_tile_priority =
 449       active_layer_->screen_space_transform_for_tile_priority();
 450
 451   // Expand viewport and set it as invalid for prioritizing tiles.
 452   // Should not update tile viewport.
 453   time_ticks += base::TimeDelta::FromMilliseconds(200);
 454   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 455   resourceless_software_draw = true;
 456   viewport = gfx::ScaleToEnclosingRect(viewport, 2);
 457   transform.Translate(1.f, 1.f);
 458   active_layer_->draw_properties().visible_content_rect = viewport;
 459   active_layer_->draw_properties().screen_space_transform = transform;
 460   host_impl_.SetExternalDrawConstraints(transform,
 461                                         viewport,
 462                                         viewport,
 463                                         viewport,
 464                                         transform,
 465                                         resourceless_software_draw);
 466   active_layer_->UpdateTiles(NULL);
 467
 468   EXPECT_RECT_EQ(visible_rect_for_tile_priority,
 469                  active_layer_->visible_rect_for_tile_priority());
 470   EXPECT_RECT_EQ(viewport_rect_for_tile_priority,
 471                  active_layer_->viewport_rect_for_tile_priority());
 472   EXPECT_TRANSFORMATION_MATRIX_EQ(
 473       screen_space_transform_for_tile_priority,
 474       active_layer_->screen_space_transform_for_tile_priority());
 475
 476   // Keep expanded viewport but mark it valid. Should update tile viewport.
 477   time_ticks += base::TimeDelta::FromMilliseconds(200);
 478   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 479   resourceless_software_draw = false;
 480   host_impl_.SetExternalDrawConstraints(transform,
 481                                         viewport,
 482                                         viewport,
 483                                         viewport,
 484                                         transform,
 485                                         resourceless_software_draw);
 486   active_layer_->UpdateTiles(NULL);
 487
 488   EXPECT_FALSE(visible_rect_for_tile_priority ==
 489                active_layer_->visible_rect_for_tile_priority());
 490   EXPECT_FALSE(viewport_rect_for_tile_priority ==
 491                active_layer_->viewport_rect_for_tile_priority());
 492   EXPECT_FALSE(screen_space_transform_for_tile_priority ==
 493                active_layer_->screen_space_transform_for_tile_priority());
 494 }
 495
 496 TEST_F(PictureLayerImplTest, InvalidViewportAfterReleaseResources) {
 497   gfx::Size tile_size(100, 100);
 498   gfx::Size layer_bounds(400, 400);
 499
 500   scoped_refptr<FakePicturePileImpl> pending_pile =
 501       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 502   scoped_refptr<FakePicturePileImpl> active_pile =
 503       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 504
 505   SetupTrees(pending_pile, active_pile);
 506
 507   Region invalidation;
 508   AddDefaultTilingsWithInvalidation(invalidation);
 509
 510   bool resourceless_software_draw = true;
 511   gfx::Rect viewport = gfx::Rect(layer_bounds);
 512   gfx::Transform identity = gfx::Transform();
 513   host_impl_.SetExternalDrawConstraints(identity,
 514                                         viewport,
 515                                         viewport,
 516                                         viewport,
 517                                         identity,
 518                                         resourceless_software_draw);
 519   ResetTilingsAndRasterScales();
 520   host_impl_.pending_tree()->UpdateDrawProperties();
 521   host_impl_.active_tree()->UpdateDrawProperties();
 522   EXPECT_TRUE(active_layer_->HighResTiling());
 523
 524   size_t num_tilings = active_layer_->num_tilings();
 525   active_layer_->UpdateTiles(NULL);
 526   pending_layer_->AddTiling(0.5f);
 527   EXPECT_EQ(num_tilings + 1, active_layer_->num_tilings());
 528 }
 529
 530 TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
 531   gfx::Size tile_size(100, 100);
 532   gfx::Size layer_bounds(400, 400);
 533   gfx::Rect layer_invalidation(150, 200, 30, 180);
 534
 535   scoped_refptr<FakePicturePileImpl> pending_pile =
 536       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 537   scoped_refptr<FakePicturePileImpl> active_pile =
 538       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 539
 540   SetupTrees(pending_pile, active_pile);
 541
 542   Region invalidation(layer_invalidation);
 543   AddDefaultTilingsWithInvalidation(invalidation);
 544
 545   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
 546   EXPECT_GT(tilings->num_tilings(), 0u);
 547   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
 548     const PictureLayerTiling* tiling = tilings->tiling_at(i);
 549     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
 550         layer_invalidation,
 551         tiling->contents_scale());
 552     for (PictureLayerTiling::CoverageIterator iter(
 553              tiling,
 554              tiling->contents_scale(),
 555              gfx::Rect(tiling->tiling_size()));
 556          iter;
 557          ++iter) {
 558       EXPECT_TRUE(*iter);
 559       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
 560       if (iter.geometry_rect().Intersects(content_invalidation))
 561         EXPECT_EQ(pending_pile, iter->picture_pile());
 562       else
 563         EXPECT_EQ(active_pile, iter->picture_pile());
 564     }
 565   }
 566 }
 567
 568 TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
 569   gfx::Size tile_size(90, 80);
 570   gfx::Size layer_bounds(300, 500);
 571
 572   scoped_refptr<FakePicturePileImpl> pending_pile =
 573       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 574   scoped_refptr<FakePicturePileImpl> active_pile =
 575       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 576
 577   SetupTrees(pending_pile, active_pile);
 578
 579   Region invalidation((gfx::Rect(layer_bounds)));
 580   AddDefaultTilingsWithInvalidation(invalidation);
 581
 582   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
 583             active_layer_->tilings()->num_tilings());
 584
 585   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
 586   EXPECT_GT(tilings->num_tilings(), 0u);
 587   for (size_t i = 0; i < tilings->num_tilings(); ++i)
 588     VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
 589 }
 590
 591 TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
 592   gfx::Size tile_size(90, 80);
 593   gfx::Size active_layer_bounds(300, 500);
 594   gfx::Size pending_layer_bounds(400, 800);
 595
 596   scoped_refptr<FakePicturePileImpl> pending_pile =
 597       FakePicturePileImpl::CreateFilledPile(tile_size,
 598                                                 pending_layer_bounds);
 599   scoped_refptr<FakePicturePileImpl> active_pile =
 600       FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
 601
 602   SetupTrees(pending_pile, active_pile);
 603   pending_layer_->set_fixed_tile_size(gfx::Size(100, 100));
 604
 605   Region invalidation;
 606   AddDefaultTilingsWithInvalidation(invalidation);
 607
 608   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
 609   EXPECT_GT(tilings->num_tilings(), 0u);
 610   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
 611     const PictureLayerTiling* tiling = tilings->tiling_at(i);
 612     gfx::Rect active_content_bounds = gfx::ScaleToEnclosingRect(
 613         gfx::Rect(active_layer_bounds),
 614         tiling->contents_scale());
 615     for (PictureLayerTiling::CoverageIterator iter(
 616              tiling,
 617              tiling->contents_scale(),
 618              gfx::Rect(tiling->tiling_size()));
 619          iter;
 620          ++iter) {
 621       EXPECT_TRUE(*iter);
 622       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
 623       std::vector<Tile*> active_tiles =
 624           active_layer_->tilings()->tiling_at(i)->AllTilesForTesting();
 625       std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting();
 626       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
 627           iter.geometry_rect().bottom() >= active_content_bounds.height() ||
 628           active_tiles[0]->content_rect().size() !=
 629               pending_tiles[0]->content_rect().size()) {
 630         EXPECT_EQ(pending_pile, iter->picture_pile());
 631       } else {
 632         EXPECT_EQ(active_pile, iter->picture_pile());
 633       }
 634     }
 635   }
 636 }
 637
 638 TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
 639   gfx::Size tile_size(400, 400);
 640   gfx::Size layer_bounds(1300, 1900);
 641
 642   scoped_refptr<FakePicturePileImpl> pending_pile =
 643       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 644   scoped_refptr<FakePicturePileImpl> active_pile =
 645       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 646
 647   // Fill in some of active pile, but more of pending pile.
 648   int hole_count = 0;
 649   for (int x = 0; x < active_pile->tiling().num_tiles_x(); ++x) {
 650     for (int y = 0; y < active_pile->tiling().num_tiles_y(); ++y) {
 651       if ((x + y) % 2) {
 652         pending_pile->AddRecordingAt(x, y);
 653         active_pile->AddRecordingAt(x, y);
 654       } else {
 655         hole_count++;
 656         if (hole_count % 2)
 657           pending_pile->AddRecordingAt(x, y);
 658       }
 659     }
 660   }
 661
 662   SetupTrees(pending_pile, active_pile);
 663   Region invalidation;
 664   AddDefaultTilingsWithInvalidation(invalidation);
 665
 666   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
 667   EXPECT_GT(tilings->num_tilings(), 0u);
 668   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
 669     const PictureLayerTiling* tiling = tilings->tiling_at(i);
 670
 671     for (PictureLayerTiling::CoverageIterator iter(
 672              tiling,
 673              tiling->contents_scale(),
 674              gfx::Rect(tiling->tiling_size()));
 675          iter;
 676          ++iter) {
 677       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
 678       // Ensure there is a recording for this tile.
 679       bool in_pending = pending_pile->CanRaster(tiling->contents_scale(),
 680                                                 iter.full_tile_geometry_rect());
 681       bool in_active = active_pile->CanRaster(tiling->contents_scale(),
 682                                               iter.full_tile_geometry_rect());
 683
 684       if (in_pending && !in_active)
 685         EXPECT_EQ(pending_pile, iter->picture_pile());
 686       else if (in_active)
 687         EXPECT_EQ(active_pile, iter->picture_pile());
 688       else
 689         EXPECT_FALSE(*iter);
 690     }
 691   }
 692 }
 693
 694 TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
 695   gfx::Size tile_size(400, 400);
 696   gfx::Size layer_bounds(1300, 1900);
 697
 698   scoped_refptr<FakePicturePileImpl> pending_pile =
 699       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 700   scoped_refptr<FakePicturePileImpl> active_pile =
 701       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 702
 703   SetupTrees(pending_pile, active_pile);
 704
 705   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 706
 707   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 708 }
 709
 710 TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
 711   gfx::Size tile_size(400, 400);
 712   gfx::Size layer_bounds(1300, 1900);
 713
 714   scoped_refptr<FakePicturePileImpl> pending_pile =
 715       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 716   scoped_refptr<FakePicturePileImpl> active_pile =
 717       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 718
 719   SetupTrees(pending_pile, active_pile);
 720   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 721
 722   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 723   EXPECT_LT(low_res_factor, 1.f);
 724
 725   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 726                                     6.f,  // ideal contents scale
 727                                     3.f,  // device scale
 728                                     2.f,  // page scale
 729                                     1.f,  // maximum animation scale
 730                                     false);
 731   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 732   EXPECT_FLOAT_EQ(6.f,
 733                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 734   EXPECT_FLOAT_EQ(6.f * low_res_factor,
 735                   pending_layer_->tilings()->tiling_at(1)->contents_scale());
 736
 737   // If we change the page scale factor, then we should get new tilings.
 738   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 739                                     6.6f,  // ideal contents scale
 740                                     3.f,   // device scale
 741                                     2.2f,  // page scale
 742                                     1.f,   // maximum animation scale
 743                                     false);
 744   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
 745   EXPECT_FLOAT_EQ(6.6f,
 746                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 747   EXPECT_FLOAT_EQ(6.6f * low_res_factor,
 748                   pending_layer_->tilings()->tiling_at(2)->contents_scale());
 749
 750   // If we change the device scale factor, then we should get new tilings.
 751   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 752                                     7.26f,  // ideal contents scale
 753                                     3.3f,   // device scale
 754                                     2.2f,   // page scale
 755                                     1.f,    // maximum animation scale
 756                                     false);
 757   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
 758   EXPECT_FLOAT_EQ(7.26f,
 759                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 760   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
 761                   pending_layer_->tilings()->tiling_at(3)->contents_scale());
 762
 763   // If we change the device scale factor, but end up at the same total scale
 764   // factor somehow, then we don't get new tilings.
 765   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 766                                     7.26f,  // ideal contents scale
 767                                     2.2f,   // device scale
 768                                     3.3f,   // page scale
 769                                     1.f,    // maximum animation scale
 770                                     false);
 771   ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
 772   EXPECT_FLOAT_EQ(7.26f,
 773                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 774   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
 775                   pending_layer_->tilings()->tiling_at(3)->contents_scale());
 776 }
 777
 778 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
 779   // This test makes sure that if a layer can have tilings, then a commit makes
 780   // it not able to have tilings (empty size), and then a future commit that
 781   // makes it valid again should be able to create tilings.
 782   gfx::Size tile_size(400, 400);
 783   gfx::Size layer_bounds(1300, 1900);
 784
 785   scoped_refptr<FakePicturePileImpl> empty_pile =
 786       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 787   scoped_refptr<FakePicturePileImpl> valid_pile =
 788       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 789
 790   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 791   EXPECT_LT(low_res_factor, 1.f);
 792
 793   float high_res_scale = 1.3f;
 794   float low_res_scale = high_res_scale * low_res_factor;
 795   float device_scale = 1.7f;
 796   float page_scale = 3.2f;
 797   float maximum_animation_scale = 1.f;
 798
 799   SetupPendingTree(valid_pile);
 800   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 801                                     high_res_scale,
 802                                     device_scale,
 803                                     page_scale,
 804                                     maximum_animation_scale,
 805                                     false);
 806   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 807   EXPECT_FLOAT_EQ(high_res_scale,
 808                   pending_layer_->HighResTiling()->contents_scale());
 809   EXPECT_FLOAT_EQ(low_res_scale,
 810                   pending_layer_->LowResTiling()->contents_scale());
 811
 812   ActivateTree();
 813   SetupPendingTree(empty_pile);
 814   EXPECT_FALSE(pending_layer_->CanHaveTilings());
 815   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 816                                     high_res_scale,
 817                                     device_scale,
 818                                     page_scale,
 819                                     maximum_animation_scale,
 820                                     false);
 821   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 822   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 823
 824   ActivateTree();
 825   EXPECT_FALSE(active_layer_->CanHaveTilings());
 826   SetupDrawPropertiesAndUpdateTiles(active_layer_,
 827                                     high_res_scale,
 828                                     device_scale,
 829                                     page_scale,
 830                                     maximum_animation_scale,
 831                                     false);
 832   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 833
 834   SetupPendingTree(valid_pile);
 835   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
 836                                     high_res_scale,
 837                                     device_scale,
 838                                     page_scale,
 839                                     maximum_animation_scale,
 840                                     false);
 841   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 842   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 843   EXPECT_FLOAT_EQ(high_res_scale,
 844                   pending_layer_->HighResTiling()->contents_scale());
 845   EXPECT_FLOAT_EQ(low_res_scale,
 846                   pending_layer_->LowResTiling()->contents_scale());
 847 }
 848
 849 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
 850   gfx::Size tile_size(400, 400);
 851   gfx::Size layer_bounds(1300, 1900);
 852
 853   // Set up the high and low res tilings before pinch zoom.
 854   scoped_refptr<FakePicturePileImpl> pending_pile =
 855       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 856   scoped_refptr<FakePicturePileImpl> active_pile =
 857       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 858
 859   SetupTrees(pending_pile, active_pile);
 860   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 861   SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, 1.0f, false);
 862   host_impl_.PinchGestureBegin();
 863   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
 864   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
 865   EXPECT_EQ(active_layer_->tilings()->NumHighResTilings(), 1);
 866 }
 867
 868 TEST_F(PictureLayerImplTest, PinchGestureTilings) {
 869   gfx::Size tile_size(400, 400);
 870   gfx::Size layer_bounds(1300, 1900);
 871
 872   scoped_refptr<FakePicturePileImpl> pending_pile =
 873       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 874   scoped_refptr<FakePicturePileImpl> active_pile =
 875       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 876
 877   // Set up the high and low res tilings before pinch zoom.
 878   SetupTrees(pending_pile, active_pile);
 879   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 880   SetContentsScaleOnBothLayers(2.0f, 1.0f, 1.0f, 1.0f, false);
 881   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 882   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
 883   EXPECT_FLOAT_EQ(2.0f,
 884                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 885   EXPECT_FLOAT_EQ(2.0f * low_res_factor,
 886                   active_layer_->tilings()->tiling_at(1)->contents_scale());
 887
 888   // Start a pinch gesture.
 889   host_impl_.PinchGestureBegin();
 890
 891   // Zoom out by a small amount. We should create a tiling at half
 892   // the scale (2/kMaxScaleRatioDuringPinch).
 893   SetContentsScaleOnBothLayers(1.8f, 1.0f, 0.9f, 1.0f, false);
 894   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 895   EXPECT_FLOAT_EQ(2.0f,
 896                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 897   EXPECT_FLOAT_EQ(1.0f,
 898                   active_layer_->tilings()->tiling_at(1)->contents_scale());
 899   EXPECT_FLOAT_EQ(2.0f * low_res_factor,
 900                   active_layer_->tilings()->tiling_at(2)->contents_scale());
 901
 902   // Zoom out further, close to our low-res scale factor. We should
 903   // use that tiling as high-res, and not create a new tiling.
 904   SetContentsScaleOnBothLayers(
 905       low_res_factor, 1.0f, low_res_factor / 2.0f, 1.0f, false);
 906   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 907
 908   // Zoom in a lot now. Since we increase by increments of
 909   // kMaxScaleRatioDuringPinch, this will first use 1.0, then 2.0
 910   // and then finally create a new tiling at 4.0.
 911   SetContentsScaleOnBothLayers(4.2f, 1.0f, 2.1f, 1.f, false);
 912   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 913   SetContentsScaleOnBothLayers(4.2f, 1.0f, 2.1f, 1.f, false);
 914   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 915   SetContentsScaleOnBothLayers(4.2f, 1.0f, 2.1f, 1.f, false);
 916   EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
 917   EXPECT_FLOAT_EQ(4.0f,
 918                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 919 }
 920
 921 TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
 922   gfx::Size tile_size(300, 300);
 923   gfx::Size layer_bounds(2600, 3800);
 924
 925   scoped_refptr<FakePicturePileImpl> pending_pile =
 926       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 927   scoped_refptr<FakePicturePileImpl> active_pile =
 928       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 929
 930   // Set up the high and low res tilings before pinch zoom.
 931   SetupTrees(pending_pile, active_pile);
 932   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 933   SetContentsScaleOnBothLayers(0.24f, 1.0f, 0.24f, 1.0f, false);
 934   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
 935   EXPECT_FLOAT_EQ(0.24f,
 936                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 937   EXPECT_FLOAT_EQ(0.0625f,
 938                   active_layer_->tilings()->tiling_at(1)->contents_scale());
 939
 940   // Start a pinch gesture.
 941   host_impl_.PinchGestureBegin();
 942
 943   // Zoom out by a small amount. We should create a tiling at half
 944   // the scale (1/kMaxScaleRatioDuringPinch).
 945   SetContentsScaleOnBothLayers(0.2f, 1.0f, 0.2f, 1.0f, false);
 946   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 947   EXPECT_FLOAT_EQ(0.24f,
 948                   active_layer_->tilings()->tiling_at(0)->contents_scale());
 949   EXPECT_FLOAT_EQ(0.12f,
 950                   active_layer_->tilings()->tiling_at(1)->contents_scale());
 951   EXPECT_FLOAT_EQ(0.0625,
 952                   active_layer_->tilings()->tiling_at(2)->contents_scale());
 953
 954   // Zoom out further, close to our low-res scale factor. We should
 955   // use that tiling as high-res, and not create a new tiling.
 956   SetContentsScaleOnBothLayers(0.1f, 1.0f, 0.1f, 1.0f, false);
 957   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 958
 959   // Zoom in. 0.125(desired_scale) should be snapped to 0.12 during zoom-in
 960   // because 0.125(desired_scale) is within the ratio(1.2)
 961   SetContentsScaleOnBothLayers(0.5f, 1.0f, 0.5f, 1.0f, false);
 962   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
 963 }
 964
 965 TEST_F(PictureLayerImplTest, CleanUpTilings) {
 966   gfx::Size tile_size(400, 400);
 967   gfx::Size layer_bounds(1300, 1900);
 968
 969   scoped_refptr<FakePicturePileImpl> pending_pile =
 970       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 971   scoped_refptr<FakePicturePileImpl> active_pile =
 972       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 973
 974   std::vector<PictureLayerTiling*> used_tilings;
 975
 976   SetupTrees(pending_pile, active_pile);
 977   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 978
 979   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 980   EXPECT_LT(low_res_factor, 1.f);
 981
 982   float device_scale = 1.7f;
 983   float page_scale = 3.2f;
 984   float scale = 1.f;
 985
 986   SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
 987   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 988
 989   // We only have ideal tilings, so they aren't removed.
 990   used_tilings.clear();
 991   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
 992   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 993
 994   host_impl_.PinchGestureBegin();
 995
 996   // Changing the ideal but not creating new tilings.
 997   scale *= 1.5f;
 998   page_scale *= 1.5f;
 999   SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
1000   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
1001
1002   // The tilings are still our target scale, so they aren't removed.
1003   used_tilings.clear();
1004   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1005   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
1006
1007   host_impl_.PinchGestureEnd();
1008
1009   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
1010   scale /= 4.f;
1011   page_scale /= 4.f;
1012   SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, false);
1013   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
1014   EXPECT_FLOAT_EQ(
1015       1.f,
1016       active_layer_->tilings()->tiling_at(1)->contents_scale());
1017   EXPECT_FLOAT_EQ(
1018       1.f * low_res_factor,
1019       active_layer_->tilings()->tiling_at(3)->contents_scale());
1020
1021   // Mark the non-ideal tilings as used. They won't be removed.
1022   used_tilings.clear();
1023   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
1024   used_tilings.push_back(active_layer_->tilings()->tiling_at(3));
1025   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1026   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
1027
1028   // Now move the ideal scale to 0.5. Our target stays 1.2.
1029   SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.f, false);
1030
1031   // The high resolution tiling is between target and ideal, so is not
1032   // removed.  The low res tiling for the old ideal=1.0 scale is removed.
1033   used_tilings.clear();
1034   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1035   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
1036
1037   // Now move the ideal scale to 1.0. Our target stays 1.2.
1038   SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
1039
1040   // All the tilings are between are target and the ideal, so they are not
1041   // removed.
1042   used_tilings.clear();
1043   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1044   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
1045
1046   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
1047   SetupDrawPropertiesAndUpdateTiles(
1048       active_layer_, 1.1f, device_scale, page_scale, 1.f, false);
1049
1050   // Because the pending layer's ideal scale is still 1.0, our tilings fall
1051   // in the range [1.0,1.2] and are kept.
1052   used_tilings.clear();
1053   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1054   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
1055
1056   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
1057   // 1.2 still.
1058   SetupDrawPropertiesAndUpdateTiles(
1059       pending_layer_, 1.1f, device_scale, page_scale, 1.f, false);
1060
1061   // Our 1.0 tiling now falls outside the range between our ideal scale and our
1062   // target raster scale. But it is in our used tilings set, so nothing is
1063   // deleted.
1064   used_tilings.clear();
1065   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
1066   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1067   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
1068
1069   // If we remove it from our used tilings set, it is outside the range to keep
1070   // so it is deleted.
1071   used_tilings.clear();
1072   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
1073   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
1074 }
1075
1076 #define EXPECT_BOTH_EQ(expression, x)         \
1077   do {                                        \
1078     EXPECT_EQ(x, pending_layer_->expression); \
1079     EXPECT_EQ(x, active_layer_->expression);  \
1080   } while (false)
1081
1082 TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
1083   // Make sure this layer covers multiple tiles, since otherwise low
1084   // res won't get created because it is too small.
1085   gfx::Size tile_size(host_impl_.settings().default_tile_size);
1086   SetupDefaultTrees(gfx::Size(tile_size.width() + 1, tile_size.height() + 1));
1087   // Avoid max untiled layer size heuristics via fixed tile size.
1088   pending_layer_->set_fixed_tile_size(tile_size);
1089   active_layer_->set_fixed_tile_size(tile_size);
1090
1091   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
1092   float contents_scale = 1.f;
1093   float device_scale = 1.f;
1094   float page_scale = 1.f;
1095   float maximum_animation_scale = 1.f;
1096   bool animating_transform = true;
1097
1098   // Animating, so don't create low res even if there isn't one already.
1099   SetContentsScaleOnBothLayers(contents_scale,
1100                                device_scale,
1101                                page_scale,
1102                                maximum_animation_scale,
1103                                animating_transform);
1104   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
1105   EXPECT_BOTH_EQ(num_tilings(), 1u);
1106
1107   // Stop animating, low res gets created.
1108   animating_transform = false;
1109   SetContentsScaleOnBothLayers(contents_scale,
1110                                device_scale,
1111                                page_scale,
1112                                maximum_animation_scale,
1113                                animating_transform);
1114   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
1115   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
1116   EXPECT_BOTH_EQ(num_tilings(), 2u);
1117
1118   // Page scale animation, new high res, but not new low res because animating.
1119   contents_scale = 2.f;
1120   page_scale = 2.f;
1121   animating_transform = true;
1122   SetContentsScaleOnBothLayers(contents_scale,
1123                                device_scale,
1124                                page_scale,
1125                                maximum_animation_scale,
1126                                animating_transform);
1127   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
1128   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), low_res_factor);
1129   EXPECT_BOTH_EQ(num_tilings(), 3u);
1130
1131   // Stop animating, new low res gets created for final page scale.
1132   animating_transform = false;
1133   SetContentsScaleOnBothLayers(contents_scale,
1134                                device_scale,
1135                                page_scale,
1136                                maximum_animation_scale,
1137                                animating_transform);
1138   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
1139   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor);
1140   EXPECT_BOTH_EQ(num_tilings(), 4u);
1141 }
1142
1143 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
1144   gfx::Size tile_size(host_impl_.settings().default_tile_size);
1145   SetupDefaultTrees(tile_size);
1146
1147   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
1148   float device_scale = 1.f;
1149   float page_scale = 1.f;
1150   float maximum_animation_scale = 1.f;
1151   bool animating_transform = false;
1152
1153   // Contents exactly fit on one tile at scale 1, no low res.
1154   float contents_scale = 1.f;
1155   SetContentsScaleOnBothLayers(contents_scale,
1156                                device_scale,
1157                                page_scale,
1158                                maximum_animation_scale,
1159                                animating_transform);
1160   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
1161   EXPECT_BOTH_EQ(num_tilings(), 1u);
1162
1163   ResetTilingsAndRasterScales();
1164
1165   // Contents that are smaller than one tile, no low res.
1166   contents_scale = 0.123f;
1167   SetContentsScaleOnBothLayers(contents_scale,
1168                                device_scale,
1169                                page_scale,
1170                                maximum_animation_scale,
1171                                animating_transform);
1172   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
1173   EXPECT_BOTH_EQ(num_tilings(), 1u);
1174
1175   ResetTilingsAndRasterScales();
1176
1177   // Any content bounds that would create more than one tile will
1178   // generate a low res tiling.
1179   contents_scale = 2.5f;
1180   SetContentsScaleOnBothLayers(contents_scale,
1181                                device_scale,
1182                                page_scale,
1183                                maximum_animation_scale,
1184                                animating_transform);
1185   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
1186   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(),
1187                  contents_scale * low_res_factor);
1188   EXPECT_BOTH_EQ(num_tilings(), 2u);
1189
1190   ResetTilingsAndRasterScales();
1191
1192   // Mask layers dont create low res since they always fit on one tile.
1193   pending_layer_->SetIsMask(true);
1194   active_layer_->SetIsMask(true);
1195   SetContentsScaleOnBothLayers(contents_scale,
1196                                device_scale,
1197                                page_scale,
1198                                maximum_animation_scale,
1199                                animating_transform);
1200   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
1201   EXPECT_BOTH_EQ(num_tilings(), 1u);
1202 }
1203
1204 TEST_F(PictureLayerImplTest, ReleaseResources) {
1205   gfx::Size tile_size(400, 400);
1206   gfx::Size layer_bounds(1300, 1900);
1207
1208   scoped_refptr<FakePicturePileImpl> pending_pile =
1209       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1210   scoped_refptr<FakePicturePileImpl> active_pile =
1211       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1212
1213   SetupTrees(pending_pile, active_pile);
1214   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1215
1216   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
1217                                     1.3f,  // ideal contents scale
1218                                     2.7f,  // device scale
1219                                     3.2f,  // page scale
1220                                     1.f,   // maximum animation scale
1221                                     false);
1222   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
1223
1224   // All tilings should be removed when losing output surface.
1225   active_layer_->ReleaseResources();
1226   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
1227   pending_layer_->ReleaseResources();
1228   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1229
1230   // This should create new tilings.
1231   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
1232                                     1.3f,  // ideal contents scale
1233                                     2.7f,  // device scale
1234                                     3.2f,  // page scale
1235                                     1.f,   // maximum animation scale
1236                                     false);
1237   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
1238 }
1239
1240 TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
1241   // The default max tile size is larger than 400x400.
1242   gfx::Size tile_size(400, 400);
1243   gfx::Size layer_bounds(5000, 5000);
1244
1245   scoped_refptr<FakePicturePileImpl> pending_pile =
1246       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1247   scoped_refptr<FakePicturePileImpl> active_pile =
1248       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1249
1250   SetupTrees(pending_pile, active_pile);
1251   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1252
1253   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
1254   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
1255
1256   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
1257
1258   // The default value.
1259   EXPECT_EQ(gfx::Size(256, 256).ToString(),
1260             host_impl_.settings().default_tile_size.ToString());
1261
1262   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
1263   EXPECT_EQ(gfx::Size(256, 256).ToString(),
1264             tile->content_rect().size().ToString());
1265
1266   pending_layer_->ReleaseResources();
1267
1268   // Change the max texture size on the output surface context.
1269   scoped_ptr<TestWebGraphicsContext3D> context =
1270       TestWebGraphicsContext3D::Create();
1271   context->set_max_texture_size(140);
1272   host_impl_.DidLoseOutputSurface();
1273   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
1274       context.Pass()).PassAs<OutputSurface>());
1275
1276   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
1277   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
1278
1279   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
1280
1281   // Verify the tiles are not larger than the context's max texture size.
1282   tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
1283   EXPECT_GE(140, tile->content_rect().width());
1284   EXPECT_GE(140, tile->content_rect().height());
1285 }
1286
1287 TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
1288   // The default max tile size is larger than 400x400.
1289   gfx::Size tile_size(400, 400);
1290   gfx::Size layer_bounds(500, 500);
1291
1292   scoped_refptr<FakePicturePileImpl> pending_pile =
1293       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1294   scoped_refptr<FakePicturePileImpl> active_pile =
1295       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1296
1297   SetupTrees(pending_pile, active_pile);
1298   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1299
1300   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
1301   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
1302
1303   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
1304
1305   // The default value. The layer is smaller than this.
1306   EXPECT_EQ(gfx::Size(512, 512).ToString(),
1307             host_impl_.settings().max_untiled_layer_size.ToString());
1308
1309   // There should be a single tile since the layer is small.
1310   PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
1311   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
1312
1313   pending_layer_->ReleaseResources();
1314
1315   // Change the max texture size on the output surface context.
1316   scoped_ptr<TestWebGraphicsContext3D> context =
1317       TestWebGraphicsContext3D::Create();
1318   context->set_max_texture_size(140);
1319   host_impl_.DidLoseOutputSurface();
1320   host_impl_.InitializeRenderer(FakeOutputSurface::Create3d(
1321       context.Pass()).PassAs<OutputSurface>());
1322
1323   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
1324   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
1325
1326   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
1327
1328   // There should be more than one tile since the max texture size won't cover
1329   // the layer.
1330   high_res_tiling = pending_layer_->tilings()->tiling_at(0);
1331   EXPECT_LT(1u, high_res_tiling->AllTilesForTesting().size());
1332
1333   // Verify the tiles are not larger than the context's max texture size.
1334   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
1335   EXPECT_GE(140, tile->content_rect().width());
1336   EXPECT_GE(140, tile->content_rect().height());
1337 }
1338
1339 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
1340   MockOcclusionTracker<LayerImpl> occlusion_tracker;
1341   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
1342
1343   gfx::Size tile_size(400, 400);
1344   gfx::Size layer_bounds(1300, 1900);
1345
1346   scoped_refptr<FakePicturePileImpl> pending_pile =
1347       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1348   scoped_refptr<FakePicturePileImpl> active_pile =
1349       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1350
1351   SetupTrees(pending_pile, active_pile);
1352
1353   active_layer_->draw_properties().visible_content_rect =
1354       gfx::Rect(layer_bounds);
1355
1356   gfx::Rect layer_invalidation(150, 200, 30, 180);
1357   Region invalidation(layer_invalidation);
1358   AddDefaultTilingsWithInvalidation(invalidation);
1359
1360   AppendQuadsData data;
1361   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL);
1362   active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
1363   active_layer_->DidDraw(NULL);
1364
1365   ASSERT_EQ(1U, render_pass->quad_list.size());
1366   EXPECT_EQ(DrawQuad::PICTURE_CONTENT, render_pass->quad_list[0]->material);
1367 }
1368
1369 TEST_F(PictureLayerImplTest, MarkRequiredNullTiles) {
1370   gfx::Size tile_size(100, 100);
1371   gfx::Size layer_bounds(1000, 1000);
1372
1373   scoped_refptr<FakePicturePileImpl> pending_pile =
1374       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
1375   // Layers with entirely empty piles can't get tilings.
1376   pending_pile->AddRecordingAt(0, 0);
1377
1378   SetupPendingTree(pending_pile);
1379
1380   ASSERT_TRUE(pending_layer_->CanHaveTilings());
1381   pending_layer_->AddTiling(1.0f);
1382   pending_layer_->AddTiling(2.0f);
1383
1384   // It should be safe to call this (and MarkVisibleResourcesAsRequired)
1385   // on a layer with no recordings.
1386   host_impl_.pending_tree()->UpdateDrawProperties();
1387   pending_layer_->MarkVisibleResourcesAsRequired();
1388 }
1389
1390 TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
1391   gfx::Size tile_size(100, 100);
1392   gfx::Size layer_bounds(200, 200);
1393
1394   scoped_refptr<FakePicturePileImpl> pending_pile =
1395       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1396   SetupPendingTree(pending_pile);
1397
1398   pending_layer_->set_fixed_tile_size(tile_size);
1399   ASSERT_TRUE(pending_layer_->CanHaveTilings());
1400   PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
1401   host_impl_.pending_tree()->UpdateDrawProperties();
1402   EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION);
1403
1404   pending_layer_->draw_properties().visible_content_rect =
1405       gfx::Rect(0, 0, 100, 200);
1406
1407   // Fake set priorities.
1408   for (PictureLayerTiling::CoverageIterator iter(
1409            tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
1410        iter;
1411        ++iter) {
1412     if (!*iter)
1413       continue;
1414     Tile* tile = *iter;
1415     TilePriority priority;
1416     priority.resolution = HIGH_RESOLUTION;
1417     gfx::Rect tile_bounds = iter.geometry_rect();
1418     if (pending_layer_->visible_content_rect().Intersects(tile_bounds)) {
1419       priority.priority_bin = TilePriority::NOW;
1420       priority.distance_to_visible = 0.f;
1421     } else {
1422       priority.priority_bin = TilePriority::SOON;
1423       priority.distance_to_visible = 1.f;
1424     }
1425     tile->SetPriority(PENDING_TREE, priority);
1426   }
1427
1428   pending_layer_->MarkVisibleResourcesAsRequired();
1429
1430   int num_visible = 0;
1431   int num_offscreen = 0;
1432
1433   for (PictureLayerTiling::CoverageIterator iter(
1434            tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
1435        iter;
1436        ++iter) {
1437     if (!*iter)
1438       continue;
1439     const Tile* tile = *iter;
1440     if (tile->priority(PENDING_TREE).distance_to_visible == 0.f) {
1441       EXPECT_TRUE(tile->required_for_activation());
1442       num_visible++;
1443     } else {
1444       EXPECT_FALSE(tile->required_for_activation());
1445       num_offscreen++;
1446     }
1447   }
1448
1449   EXPECT_GT(num_visible, 0);
1450   EXPECT_GT(num_offscreen, 0);
1451 }
1452
1453 TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
1454   gfx::Size layer_bounds(400, 400);
1455   gfx::Size tile_size(100, 100);
1456   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
1457
1458   // No tiles shared.
1459   pending_layer_->set_invalidation(gfx::Rect(layer_bounds));
1460
1461   CreateHighLowResAndSetAllTilesVisible();
1462
1463   active_layer_->SetAllTilesReady();
1464
1465   // No shared tiles and all active tiles ready, so pending can only
1466   // activate with all high res tiles.
1467   pending_layer_->MarkVisibleResourcesAsRequired();
1468   AssertAllTilesRequired(pending_layer_->HighResTiling());
1469   AssertNoTilesRequired(pending_layer_->LowResTiling());
1470 }
1471
1472 TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
1473   gfx::Size layer_bounds(400, 400);
1474   gfx::Size tile_size(100, 100);
1475   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
1476
1477   // All tiles shared (no invalidation).
1478   CreateHighLowResAndSetAllTilesVisible();
1479
1480   // Verify active tree not ready.
1481   Tile* some_active_tile =
1482       active_layer_->HighResTiling()->AllTilesForTesting()[0];
1483   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
1484
1485   // When high res are required, even if the active tree is not ready,
1486   // the high res tiles must be ready.
1487   host_impl_.active_tree()->SetRequiresHighResToDraw();
1488   pending_layer_->MarkVisibleResourcesAsRequired();
1489   AssertAllTilesRequired(pending_layer_->HighResTiling());
1490   AssertNoTilesRequired(pending_layer_->LowResTiling());
1491 }
1492
1493 TEST_F(PictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) {
1494   gfx::Size layer_bounds(400, 400);
1495   gfx::Size tile_size(100, 100);
1496   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
1497
1498   CreateHighLowResAndSetAllTilesVisible();
1499
1500   Tile* some_active_tile =
1501       active_layer_->HighResTiling()->AllTilesForTesting()[0];
1502   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
1503
1504   // All tiles shared (no invalidation), so even though the active tree's
1505   // tiles aren't ready, there is nothing required.
1506   pending_layer_->MarkVisibleResourcesAsRequired();
1507   AssertNoTilesRequired(pending_layer_->HighResTiling());
1508   AssertNoTilesRequired(pending_layer_->LowResTiling());
1509 }
1510
1511 TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
1512   gfx::Size layer_bounds(400, 400);
1513   gfx::Size tile_size(100, 100);
1514   scoped_refptr<FakePicturePileImpl> pending_pile =
1515       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1516   // This pile will create tilings, but has no recordings so will not create any
1517   // tiles.  This is attempting to simulate scrolling past the end of recorded
1518   // content on the active layer, where the recordings are so far away that
1519   // no tiles are created.
1520   scoped_refptr<FakePicturePileImpl> active_pile =
1521       FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
1522           tile_size, layer_bounds);
1523   SetupTrees(pending_pile, active_pile);
1524   pending_layer_->set_fixed_tile_size(tile_size);
1525   active_layer_->set_fixed_tile_size(tile_size);
1526
1527   CreateHighLowResAndSetAllTilesVisible();
1528
1529   // Active layer has tilings, but no tiles due to missing recordings.
1530   EXPECT_TRUE(active_layer_->CanHaveTilings());
1531   EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u);
1532   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
1533
1534   // Since the active layer has no tiles at all, the pending layer doesn't
1535   // need content in order to activate.
1536   pending_layer_->MarkVisibleResourcesAsRequired();
1537   AssertNoTilesRequired(pending_layer_->HighResTiling());
1538   AssertNoTilesRequired(pending_layer_->LowResTiling());
1539 }
1540
1541 TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
1542   gfx::Size layer_bounds(400, 400);
1543   gfx::Size tile_size(100, 100);
1544   scoped_refptr<FakePicturePileImpl> pending_pile =
1545       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1546   scoped_refptr<FakePicturePileImpl> active_pile =
1547       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
1548   SetupTrees(pending_pile, active_pile);
1549   pending_layer_->set_fixed_tile_size(tile_size);
1550   active_layer_->set_fixed_tile_size(tile_size);
1551
1552   CreateHighLowResAndSetAllTilesVisible();
1553
1554   // Active layer can't have tiles.
1555   EXPECT_FALSE(active_layer_->CanHaveTilings());
1556
1557   // All high res tiles required.  This should be considered identical
1558   // to the case where there is no active layer, to avoid flashing content.
1559   // This can happen if a layer exists for a while and switches from
1560   // not being able to have content to having content.
1561   pending_layer_->MarkVisibleResourcesAsRequired();
1562   AssertAllTilesRequired(pending_layer_->HighResTiling());
1563   AssertNoTilesRequired(pending_layer_->LowResTiling());
1564 }
1565
1566 TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
1567   gfx::Size layer_bounds(200, 200);
1568   gfx::Size tile_size(100, 100);
1569   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
1570
1571   gfx::Size pending_layer_bounds(400, 400);
1572   pending_layer_->SetBounds(pending_layer_bounds);
1573
1574   CreateHighLowResAndSetAllTilesVisible();
1575
1576   active_layer_->SetAllTilesReady();
1577
1578   // Since the active layer has different bounds, the pending layer needs all
1579   // high res tiles in order to activate.
1580   pending_layer_->MarkVisibleResourcesAsRequired();
1581   AssertAllTilesRequired(pending_layer_->HighResTiling());
1582   AssertNoTilesRequired(pending_layer_->LowResTiling());
1583 }
1584
1585 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
1586   gfx::Size tile_size(100, 100);
1587   gfx::Size layer_bounds(400, 400);
1588   scoped_refptr<FakePicturePileImpl> pending_pile =
1589       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1590
1591   host_impl_.CreatePendingTree();
1592   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
1593
1594   scoped_ptr<FakePictureLayerImpl> pending_layer =
1595       FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile);
1596   pending_layer->SetDrawsContent(true);
1597   pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
1598
1599   pending_layer_ = static_cast<FakePictureLayerImpl*>(
1600       host_impl_.pending_tree()->LayerById(id_));
1601
1602   // Set some state on the pending layer, make sure it is not clobbered
1603   // by a sync from the active layer.  This could happen because if the
1604   // pending layer has not been post-commit initialized it will attempt
1605   // to sync from the active layer.
1606   float raster_page_scale = 10.f * pending_layer_->raster_page_scale();
1607   pending_layer_->set_raster_page_scale(raster_page_scale);
1608   EXPECT_TRUE(pending_layer_->needs_post_commit_initialization());
1609
1610   host_impl_.ActivateSyncTree();
1611
1612   active_layer_ = static_cast<FakePictureLayerImpl*>(
1613       host_impl_.active_tree()->LayerById(id_));
1614
1615   EXPECT_EQ(0u, active_layer_->num_tilings());
1616   EXPECT_EQ(raster_page_scale, active_layer_->raster_page_scale());
1617   EXPECT_FALSE(active_layer_->needs_post_commit_initialization());
1618 }
1619
1620 TEST_F(PictureLayerImplTest, ShareTilesOnSync) {
1621   SetupDefaultTrees(gfx::Size(1500, 1500));
1622   AddDefaultTilingsWithInvalidation(gfx::Rect());
1623
1624   host_impl_.ActivateSyncTree();
1625   host_impl_.CreatePendingTree();
1626   active_layer_ = static_cast<FakePictureLayerImpl*>(
1627       host_impl_.active_tree()->LayerById(id_));
1628
1629   // Force the active tree to sync to the pending tree "post-commit".
1630   pending_layer_->DoPostCommitInitializationIfNeeded();
1631
1632   // Both invalidations should drop tiles from the pending tree.
1633   EXPECT_EQ(3u, active_layer_->num_tilings());
1634   EXPECT_EQ(3u, pending_layer_->num_tilings());
1635   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
1636     PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
1637     PictureLayerTiling* pending_tiling =
1638         pending_layer_->tilings()->tiling_at(i);
1639
1640     ASSERT_TRUE(active_tiling);
1641     ASSERT_TRUE(pending_tiling);
1642
1643     EXPECT_TRUE(active_tiling->TileAt(0, 0));
1644     EXPECT_TRUE(active_tiling->TileAt(1, 0));
1645     EXPECT_TRUE(active_tiling->TileAt(0, 1));
1646     EXPECT_TRUE(active_tiling->TileAt(1, 1));
1647
1648     EXPECT_TRUE(pending_tiling->TileAt(0, 0));
1649     EXPECT_TRUE(pending_tiling->TileAt(1, 0));
1650     EXPECT_TRUE(pending_tiling->TileAt(0, 1));
1651     EXPECT_TRUE(pending_tiling->TileAt(1, 1));
1652
1653     EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
1654     EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
1655     EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
1656     EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
1657   }
1658 }
1659
1660 TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTilesOnSync) {
1661   SetupDefaultTrees(gfx::Size(1500, 1500));
1662   AddDefaultTilingsWithInvalidation(gfx::Rect(0, 0, 1, 1));
1663
1664   // This activates the 0,0,1,1 invalidation.
1665   host_impl_.ActivateSyncTree();
1666   host_impl_.CreatePendingTree();
1667   active_layer_ = static_cast<FakePictureLayerImpl*>(
1668       host_impl_.active_tree()->LayerById(id_));
1669
1670   // Force the active tree to sync to the pending tree "post-commit".
1671   pending_layer_->DoPostCommitInitializationIfNeeded();
1672
1673   // The active tree invalidation was handled by the active tiles, so they
1674   // can be shared with the pending tree.
1675   EXPECT_EQ(3u, active_layer_->num_tilings());
1676   EXPECT_EQ(3u, pending_layer_->num_tilings());
1677   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
1678     PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
1679     PictureLayerTiling* pending_tiling =
1680         pending_layer_->tilings()->tiling_at(i);
1681
1682     ASSERT_TRUE(active_tiling);
1683     ASSERT_TRUE(pending_tiling);
1684
1685     EXPECT_TRUE(active_tiling->TileAt(0, 0));
1686     EXPECT_TRUE(active_tiling->TileAt(1, 0));
1687     EXPECT_TRUE(active_tiling->TileAt(0, 1));
1688     EXPECT_TRUE(active_tiling->TileAt(1, 1));
1689
1690     EXPECT_TRUE(pending_tiling->TileAt(0, 0));
1691     EXPECT_TRUE(pending_tiling->TileAt(1, 0));
1692     EXPECT_TRUE(pending_tiling->TileAt(0, 1));
1693     EXPECT_TRUE(pending_tiling->TileAt(1, 1));
1694
1695     EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
1696     EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
1697     EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
1698     EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
1699   }
1700 }
1701
1702 TEST_F(PictureLayerImplTest, RemoveInvalidPendingTreeTilesOnSync) {
1703   SetupDefaultTrees(gfx::Size(1500, 1500));
1704   AddDefaultTilingsWithInvalidation(gfx::Rect());
1705
1706   host_impl_.ActivateSyncTree();
1707   host_impl_.CreatePendingTree();
1708   active_layer_ = static_cast<FakePictureLayerImpl*>(
1709       host_impl_.active_tree()->LayerById(id_));
1710
1711   // Set some invalidation on the pending tree "during commit". We should
1712   // replace raster tiles that touch this.
1713   pending_layer_->set_invalidation(gfx::Rect(1, 1));
1714
1715   // Force the active tree to sync to the pending tree "post-commit".
1716   pending_layer_->DoPostCommitInitializationIfNeeded();
1717
1718   // The pending tree invalidation means tiles can not be shared with the
1719   // active tree.
1720   EXPECT_EQ(3u, active_layer_->num_tilings());
1721   EXPECT_EQ(3u, pending_layer_->num_tilings());
1722   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
1723     PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
1724     PictureLayerTiling* pending_tiling =
1725         pending_layer_->tilings()->tiling_at(i);
1726
1727     ASSERT_TRUE(active_tiling);
1728     ASSERT_TRUE(pending_tiling);
1729
1730     EXPECT_TRUE(active_tiling->TileAt(0, 0));
1731     EXPECT_TRUE(active_tiling->TileAt(1, 0));
1732     EXPECT_TRUE(active_tiling->TileAt(0, 1));
1733     EXPECT_TRUE(active_tiling->TileAt(1, 1));
1734
1735     EXPECT_TRUE(pending_tiling->TileAt(0, 0));
1736     EXPECT_TRUE(pending_tiling->TileAt(1, 0));
1737     EXPECT_TRUE(pending_tiling->TileAt(0, 1));
1738     EXPECT_TRUE(pending_tiling->TileAt(1, 1));
1739
1740     EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
1741     EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
1742     EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
1743     EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
1744   }
1745 }
1746
1747 TEST_F(PictureLayerImplTest, SyncTilingAfterReleaseResource) {
1748   SetupDefaultTrees(gfx::Size(10, 10));
1749   host_impl_.active_tree()->UpdateDrawProperties();
1750   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
1751
1752   // Contrived unit test of a real crash. A layer is transparent during a
1753   // context loss, and later becomes opaque, causing active layer SyncTiling to
1754   // be called.
1755   float new_scale = 1.f;
1756   active_layer_->ReleaseResources();
1757   pending_layer_->ReleaseResources();
1758   EXPECT_FALSE(active_layer_->tilings()->TilingAtScale(new_scale));
1759   pending_layer_->AddTiling(new_scale);
1760   EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(new_scale));
1761
1762   // UpdateDrawProperties early-outs if the tree doesn't need it.  It is also
1763   // responsible for calling ManageTilings.  These checks verify that
1764   // ReleaseResources has set needs update draw properties so that the
1765   // new tiling gets the appropriate resolution set in ManageTilings.
1766   EXPECT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
1767   host_impl_.active_tree()->UpdateDrawProperties();
1768   PictureLayerTiling* high_res =
1769       active_layer_->tilings()->TilingAtScale(new_scale);
1770   ASSERT_TRUE(!!high_res);
1771   EXPECT_EQ(HIGH_RESOLUTION, high_res->resolution());
1772 }
1773
1774 TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
1775   SetupDefaultTrees(gfx::Size(10, 10));
1776
1777   const float kScale = 1.f;
1778   pending_layer_->AddTiling(kScale);
1779   EXPECT_TRUE(pending_layer_->tilings()->TilingAtScale(kScale));
1780   EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(kScale));
1781
1782   // Gpu rasterization is disabled by default.
1783   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
1784   // Toggling the gpu rasterization clears all tilings on both trees.
1785   host_impl_.SetUseGpuRasterization(true);
1786   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1787   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
1788
1789   // Make sure that we can still add tiling to the pending layer,
1790   // that gets synced to the active layer.
1791   pending_layer_->AddTiling(kScale);
1792   EXPECT_TRUE(pending_layer_->tilings()->TilingAtScale(kScale));
1793   EXPECT_TRUE(active_layer_->tilings()->TilingAtScale(kScale));
1794
1795   // Toggling the gpu rasterization clears all tilings on both trees.
1796   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
1797   host_impl_.SetUseGpuRasterization(false);
1798   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1799   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
1800 }
1801
1802 TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
1803   SetupDefaultTrees(gfx::Size(10, 10));
1804   host_impl_.active_tree()->UpdateDrawProperties();
1805   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
1806
1807   SetupDrawPropertiesAndUpdateTiles(
1808       active_layer_, 0.5f, 0.5f, 0.5f, 0.5f, false);
1809   active_layer_->tilings()->RemoveAllTilings();
1810   PictureLayerTiling* tiling = active_layer_->tilings()->AddTiling(0.5f);
1811   active_layer_->tilings()->AddTiling(1.5f);
1812   active_layer_->tilings()->AddTiling(0.25f);
1813   tiling->set_resolution(HIGH_RESOLUTION);
1814
1815   // Sanity checks.
1816   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
1817   ASSERT_EQ(tiling, active_layer_->tilings()->TilingAtScale(0.5f));
1818
1819   // Now, set the bounds to be 1x1 (so that minimum contents scale becomes
1820   // 1.0f). Note that we should also ensure that the pending layer needs post
1821   // commit initialization, since this is what would happen during commit. In
1822   // other words we want the pending layer to sync from the active layer.
1823   pending_layer_->SetBounds(gfx::Size(1, 1));
1824   pending_layer_->SetNeedsPostCommitInitialization();
1825   pending_layer_->set_twin_layer(NULL);
1826   active_layer_->set_twin_layer(NULL);
1827   EXPECT_TRUE(pending_layer_->needs_post_commit_initialization());
1828
1829   // Update the draw properties: sync from active tree should happen here.
1830   host_impl_.pending_tree()->UpdateDrawProperties();
1831
1832   // Another sanity check.
1833   ASSERT_EQ(1.f, pending_layer_->MinimumContentsScale());
1834
1835   // Now we should've synced 1.5f tiling, since that's the only one that doesn't
1836   // violate minimum contents scale. At the same time, we should've created a
1837   // new high res tiling at scale 1.0f.
1838   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
1839   ASSERT_TRUE(pending_layer_->tilings()->TilingAtScale(1.0f));
1840   EXPECT_EQ(HIGH_RESOLUTION,
1841             pending_layer_->tilings()->TilingAtScale(1.0f)->resolution());
1842   ASSERT_TRUE(pending_layer_->tilings()->TilingAtScale(1.5f));
1843   EXPECT_EQ(NON_IDEAL_RESOLUTION,
1844             pending_layer_->tilings()->TilingAtScale(1.5f)->resolution());
1845 }
1846
1847 TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
1848   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
1849   gfx::Size layer_bounds(default_tile_size.width() * 4,
1850                          default_tile_size.height() * 4);
1851
1852   SetupDefaultTrees(layer_bounds);
1853   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
1854   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
1855   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
1856   // Should have a low-res and a high-res tiling.
1857   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
1858
1859   ResetTilingsAndRasterScales();
1860
1861   host_impl_.SetUseGpuRasterization(true);
1862   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
1863   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
1864
1865   // Should only have the high-res tiling.
1866   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
1867 }
1868
1869 TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
1870   // Set up layers with tilings.
1871   SetupDefaultTrees(gfx::Size(10, 10));
1872   SetContentsScaleOnBothLayers(1.f, 1.f, 1.f, 1.f, false);
1873   pending_layer_->PushPropertiesTo(active_layer_);
1874   EXPECT_TRUE(pending_layer_->DrawsContent());
1875   EXPECT_TRUE(pending_layer_->CanHaveTilings());
1876   EXPECT_GE(pending_layer_->num_tilings(), 0u);
1877   EXPECT_GE(active_layer_->num_tilings(), 0u);
1878
1879   // Set content to false, which should make CanHaveTilings return false.
1880   pending_layer_->SetDrawsContent(false);
1881   EXPECT_FALSE(pending_layer_->DrawsContent());
1882   EXPECT_FALSE(pending_layer_->CanHaveTilings());
1883
1884   // No tilings should be pushed to active layer.
1885   pending_layer_->PushPropertiesTo(active_layer_);
1886   EXPECT_EQ(0u, active_layer_->num_tilings());
1887 }
1888
1889 TEST_F(PictureLayerImplTest, FirstTilingDuringPinch) {
1890   SetupDefaultTrees(gfx::Size(10, 10));
1891   host_impl_.PinchGestureBegin();
1892   float high_res_scale = 2.3f;
1893   SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
1894
1895   ASSERT_GE(pending_layer_->num_tilings(), 0u);
1896   EXPECT_FLOAT_EQ(high_res_scale,
1897                   pending_layer_->HighResTiling()->contents_scale());
1898 }
1899
1900 TEST_F(PictureLayerImplTest, FirstTilingTooSmall) {
1901   SetupDefaultTrees(gfx::Size(10, 10));
1902   host_impl_.PinchGestureBegin();
1903   float high_res_scale = 0.0001f;
1904   EXPECT_GT(pending_layer_->MinimumContentsScale(), high_res_scale);
1905
1906   SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
1907
1908   ASSERT_GE(pending_layer_->num_tilings(), 0u);
1909   EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
1910                   pending_layer_->HighResTiling()->contents_scale());
1911 }
1912
1913 TEST_F(PictureLayerImplTest, PinchingTooSmall) {
1914   SetupDefaultTrees(gfx::Size(10, 10));
1915
1916   float contents_scale = 0.15f;
1917   SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, 1.f, false);
1918
1919   ASSERT_GE(pending_layer_->num_tilings(), 0u);
1920   EXPECT_FLOAT_EQ(contents_scale,
1921                   pending_layer_->HighResTiling()->contents_scale());
1922
1923   host_impl_.PinchGestureBegin();
1924
1925   float page_scale = 0.0001f;
1926   EXPECT_LT(page_scale * contents_scale,
1927             pending_layer_->MinimumContentsScale());
1928
1929   SetContentsScaleOnBothLayers(contents_scale, 1.f, page_scale, 1.f, false);
1930   ASSERT_GE(pending_layer_->num_tilings(), 0u);
1931   EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
1932                   pending_layer_->HighResTiling()->contents_scale());
1933 }
1934
1935 class DeferredInitPictureLayerImplTest : public PictureLayerImplTest {
1936  public:
1937   virtual void InitializeRenderer() OVERRIDE {
1938     bool delegated_rendering = false;
1939     host_impl_.InitializeRenderer(
1940         FakeOutputSurface::CreateDeferredGL(
1941             scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
1942             delegated_rendering).PassAs<OutputSurface>());
1943   }
1944
1945   virtual void SetUp() OVERRIDE {
1946     PictureLayerImplTest::SetUp();
1947
1948     // Create some default active and pending trees.
1949     gfx::Size tile_size(100, 100);
1950     gfx::Size layer_bounds(400, 400);
1951
1952     scoped_refptr<FakePicturePileImpl> pending_pile =
1953         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1954     scoped_refptr<FakePicturePileImpl> active_pile =
1955         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
1956
1957     SetupTrees(pending_pile, active_pile);
1958   }
1959 };
1960
1961 // This test is really a LayerTreeHostImpl test, in that it makes sure
1962 // that trees need update draw properties after deferred initialization.
1963 // However, this is also a regression test for PictureLayerImpl in that
1964 // not having this update will cause a crash.
1965 TEST_F(DeferredInitPictureLayerImplTest, PreventUpdateTilesDuringLostContext) {
1966   host_impl_.pending_tree()->UpdateDrawProperties();
1967   host_impl_.active_tree()->UpdateDrawProperties();
1968   EXPECT_FALSE(host_impl_.pending_tree()->needs_update_draw_properties());
1969   EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
1970
1971   FakeOutputSurface* fake_output_surface =
1972       static_cast<FakeOutputSurface*>(host_impl_.output_surface());
1973   ASSERT_TRUE(fake_output_surface->InitializeAndSetContext3d(
1974       TestContextProvider::Create()));
1975
1976   // These will crash PictureLayerImpl if this is not true.
1977   ASSERT_TRUE(host_impl_.pending_tree()->needs_update_draw_properties());
1978   ASSERT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
1979   host_impl_.active_tree()->UpdateDrawProperties();
1980 }
1981
1982 TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForCpuRasterization) {
1983   gfx::Size layer_bounds(100, 100);
1984   gfx::Size viewport_size(1000, 1000);
1985   SetupDefaultTrees(layer_bounds);
1986   host_impl_.SetViewportSize(viewport_size);
1987
1988   float contents_scale = 1.f;
1989   float device_scale = 1.3f;
1990   float page_scale = 1.4f;
1991   float maximum_animation_scale = 1.f;
1992   bool animating_transform = false;
1993
1994   SetContentsScaleOnBothLayers(contents_scale,
1995                                device_scale,
1996                                page_scale,
1997                                maximum_animation_scale,
1998                                animating_transform);
1999   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
2000
2001   // Since we're CPU-rasterizing, starting an animation should cause tiling
2002   // resolution to get set to the maximum animation scale factor.
2003   animating_transform = true;
2004   maximum_animation_scale = 3.f;
2005   contents_scale = 2.f;
2006
2007   SetContentsScaleOnBothLayers(contents_scale,
2008                                device_scale,
2009                                page_scale,
2010                                maximum_animation_scale,
2011                                animating_transform);
2012   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
2013
2014   // Further changes to scale during the animation should not cause a new
2015   // high-res tiling to get created.
2016   contents_scale = 4.f;
2017   maximum_animation_scale = 5.f;
2018
2019   SetContentsScaleOnBothLayers(contents_scale,
2020                                device_scale,
2021                                page_scale,
2022                                maximum_animation_scale,
2023                                animating_transform);
2024   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
2025
2026   // Once we stop animating, a new high-res tiling should be created.
2027   animating_transform = false;
2028
2029   SetContentsScaleOnBothLayers(contents_scale,
2030                                device_scale,
2031                                page_scale,
2032                                maximum_animation_scale,
2033                                animating_transform);
2034   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
2035
2036   // When animating with an unknown maximum animation scale factor, a new
2037   // high-res tiling should be created at the animation's initial scale.
2038   animating_transform = true;
2039   contents_scale = 2.f;
2040   maximum_animation_scale = 0.f;
2041
2042   SetContentsScaleOnBothLayers(contents_scale,
2043                                device_scale,
2044                                page_scale,
2045                                maximum_animation_scale,
2046                                animating_transform);
2047   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
2048
2049   // Further changes to scale during the animation should not cause a new
2050   // high-res tiling to get created.
2051   contents_scale = 3.f;
2052
2053   SetContentsScaleOnBothLayers(contents_scale,
2054                                device_scale,
2055                                page_scale,
2056                                maximum_animation_scale,
2057                                animating_transform);
2058   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
2059
2060   // Once we stop animating, a new high-res tiling should be created.
2061   animating_transform = false;
2062   contents_scale = 4.f;
2063
2064   SetContentsScaleOnBothLayers(contents_scale,
2065                                device_scale,
2066                                page_scale,
2067                                maximum_animation_scale,
2068                                animating_transform);
2069   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
2070
2071   // When animating with a maxmium animation scale factor that is so large
2072   // that the layer grows larger than the viewport at this scale, a new
2073   // high-res tiling should get created at the animation's initial scale, not
2074   // at its maximum scale.
2075   animating_transform = true;
2076   contents_scale = 2.f;
2077   maximum_animation_scale = 11.f;
2078
2079   SetContentsScaleOnBothLayers(contents_scale,
2080                                device_scale,
2081                                page_scale,
2082                                maximum_animation_scale,
2083                                animating_transform);
2084   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
2085
2086   // Once we stop animating, a new high-res tiling should be created.
2087   animating_transform = false;
2088   contents_scale = 11.f;
2089
2090   SetContentsScaleOnBothLayers(contents_scale,
2091                                device_scale,
2092                                page_scale,
2093                                maximum_animation_scale,
2094                                animating_transform);
2095   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 11.f);
2096
2097   // When animating with a maxmium animation scale factor that is so large
2098   // that the layer grows larger than the viewport at this scale, and where
2099   // the intial source scale is < 1, a new high-res tiling should get created
2100   // at source scale 1.
2101   animating_transform = true;
2102   contents_scale = 0.1f;
2103   maximum_animation_scale = 11.f;
2104
2105   SetContentsScaleOnBothLayers(contents_scale,
2106                                device_scale,
2107                                page_scale,
2108                                maximum_animation_scale,
2109                                animating_transform);
2110   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), device_scale * page_scale);
2111
2112   // Once we stop animating, a new high-res tiling should be created.
2113   animating_transform = false;
2114   contents_scale = 11.f;
2115
2116   SetContentsScaleOnBothLayers(contents_scale,
2117                                device_scale,
2118                                page_scale,
2119                                maximum_animation_scale,
2120                                animating_transform);
2121   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 11.f);
2122 }
2123
2124 TEST_F(PictureLayerImplTest, LayerRasterTileIterator) {
2125   gfx::Size tile_size(100, 100);
2126   gfx::Size layer_bounds(1000, 1000);
2127
2128   scoped_refptr<FakePicturePileImpl> pending_pile =
2129       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2130
2131   SetupPendingTree(pending_pile);
2132
2133   ASSERT_TRUE(pending_layer_->CanHaveTilings());
2134
2135   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
2136
2137   // Empty iterator
2138   PictureLayerImpl::LayerRasterTileIterator it;
2139   EXPECT_FALSE(it);
2140
2141   // No tilings.
2142   it = PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
2143   EXPECT_FALSE(it);
2144
2145   pending_layer_->AddTiling(low_res_factor);
2146   pending_layer_->AddTiling(0.3f);
2147   pending_layer_->AddTiling(0.7f);
2148   PictureLayerTiling* high_res_tiling = pending_layer_->AddTiling(1.0f);
2149   pending_layer_->AddTiling(2.0f);
2150
2151   host_impl_.SetViewportSize(gfx::Size(500, 500));
2152   host_impl_.pending_tree()->UpdateDrawProperties();
2153
2154   std::set<Tile*> unique_tiles;
2155   bool reached_prepaint = false;
2156   size_t non_ideal_tile_count = 0u;
2157   size_t low_res_tile_count = 0u;
2158   size_t high_res_tile_count = 0u;
2159   for (it = PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
2160        it;
2161        ++it) {
2162     Tile* tile = *it;
2163     TilePriority priority = tile->priority(PENDING_TREE);
2164
2165     EXPECT_TRUE(tile);
2166
2167     // Non-high res tiles only get visible tiles. Also, prepaint should only
2168     // come at the end of the iteration.
2169     if (priority.resolution != HIGH_RESOLUTION)
2170       EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
2171     else if (reached_prepaint)
2172       EXPECT_NE(TilePriority::NOW, priority.priority_bin);
2173     else
2174       reached_prepaint = priority.priority_bin != TilePriority::NOW;
2175
2176     non_ideal_tile_count += priority.resolution == NON_IDEAL_RESOLUTION;
2177     low_res_tile_count += priority.resolution == LOW_RESOLUTION;
2178     high_res_tile_count += priority.resolution == HIGH_RESOLUTION;
2179
2180     unique_tiles.insert(tile);
2181   }
2182
2183   EXPECT_TRUE(reached_prepaint);
2184   EXPECT_EQ(0u, non_ideal_tile_count);
2185   EXPECT_EQ(1u, low_res_tile_count);
2186   EXPECT_EQ(16u, high_res_tile_count);
2187   EXPECT_EQ(low_res_tile_count + high_res_tile_count + non_ideal_tile_count,
2188             unique_tiles.size());
2189
2190   std::vector<Tile*> high_res_tiles = high_res_tiling->AllTilesForTesting();
2191   for (std::vector<Tile*>::iterator tile_it = high_res_tiles.begin();
2192        tile_it != high_res_tiles.end();
2193        ++tile_it) {
2194     Tile* tile = *tile_it;
2195     ManagedTileState::TileVersion& tile_version =
2196         tile->GetTileVersionForTesting(
2197             tile->DetermineRasterModeForTree(ACTIVE_TREE));
2198     tile_version.SetSolidColorForTesting(SK_ColorRED);
2199   }
2200
2201   non_ideal_tile_count = 0;
2202   low_res_tile_count = 0;
2203   high_res_tile_count = 0;
2204   for (it = PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
2205        it;
2206        ++it) {
2207     Tile* tile = *it;
2208     TilePriority priority = tile->priority(PENDING_TREE);
2209
2210     EXPECT_TRUE(tile);
2211
2212     non_ideal_tile_count += priority.resolution == NON_IDEAL_RESOLUTION;
2213     low_res_tile_count += priority.resolution == LOW_RESOLUTION;
2214     high_res_tile_count += priority.resolution == HIGH_RESOLUTION;
2215   }
2216
2217   EXPECT_EQ(0u, non_ideal_tile_count);
2218   EXPECT_EQ(1u, low_res_tile_count);
2219   EXPECT_EQ(0u, high_res_tile_count);
2220 }
2221
2222 TEST_F(PictureLayerImplTest, LayerEvictionTileIterator) {
2223   gfx::Size tile_size(100, 100);
2224   gfx::Size layer_bounds(1000, 1000);
2225
2226   scoped_refptr<FakePicturePileImpl> pending_pile =
2227       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2228
2229   SetupPendingTree(pending_pile);
2230
2231   ASSERT_TRUE(pending_layer_->CanHaveTilings());
2232
2233   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
2234
2235   std::vector<PictureLayerTiling*> tilings;
2236   tilings.push_back(pending_layer_->AddTiling(low_res_factor));
2237   tilings.push_back(pending_layer_->AddTiling(0.3f));
2238   tilings.push_back(pending_layer_->AddTiling(0.7f));
2239   tilings.push_back(pending_layer_->AddTiling(1.0f));
2240   tilings.push_back(pending_layer_->AddTiling(2.0f));
2241
2242   host_impl_.SetViewportSize(gfx::Size(500, 500));
2243   host_impl_.pending_tree()->UpdateDrawProperties();
2244
2245   std::vector<Tile*> all_tiles;
2246   for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
2247            tilings.begin();
2248        tiling_iterator != tilings.end();
2249        ++tiling_iterator) {
2250     std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
2251     std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
2252   }
2253
2254   std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
2255
2256   bool mark_required = false;
2257   size_t number_of_marked_tiles = 0u;
2258   size_t number_of_unmarked_tiles = 0u;
2259   for (size_t i = 0; i < tilings.size(); ++i) {
2260     PictureLayerTiling* tiling = tilings.at(i);
2261     for (PictureLayerTiling::CoverageIterator iter(
2262              tiling,
2263              pending_layer_->contents_scale_x(),
2264              pending_layer_->visible_content_rect());
2265          iter;
2266          ++iter) {
2267       if (mark_required) {
2268         number_of_marked_tiles++;
2269         iter->MarkRequiredForActivation();
2270       } else {
2271         number_of_unmarked_tiles++;
2272       }
2273       mark_required = !mark_required;
2274     }
2275   }
2276
2277   // Sanity checks.
2278   EXPECT_EQ(91u, all_tiles.size());
2279   EXPECT_EQ(91u, all_tiles_set.size());
2280   EXPECT_GT(number_of_marked_tiles, 1u);
2281   EXPECT_GT(number_of_unmarked_tiles, 1u);
2282
2283   // Empty iterator.
2284   PictureLayerImpl::LayerEvictionTileIterator it;
2285   EXPECT_FALSE(it);
2286
2287   // Tiles don't have resources yet.
2288   it = PictureLayerImpl::LayerEvictionTileIterator(
2289       pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
2290   EXPECT_FALSE(it);
2291
2292   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
2293
2294   std::set<Tile*> unique_tiles;
2295   float expected_scales[] = {2.0f, 0.3f, 0.7f, low_res_factor, 1.0f};
2296   size_t scale_index = 0;
2297   bool reached_visible = false;
2298   Tile* last_tile = NULL;
2299   for (it = PictureLayerImpl::LayerEvictionTileIterator(
2300            pending_layer_, SAME_PRIORITY_FOR_BOTH_TREES);
2301        it;
2302        ++it) {
2303     Tile* tile = *it;
2304     if (!last_tile)
2305       last_tile = tile;
2306
2307     EXPECT_TRUE(tile);
2308
2309     TilePriority priority = tile->priority(PENDING_TREE);
2310
2311     if (priority.priority_bin == TilePriority::NOW) {
2312       reached_visible = true;
2313       last_tile = tile;
2314       break;
2315     }
2316
2317     EXPECT_FALSE(tile->required_for_activation());
2318
2319     while (std::abs(tile->contents_scale() - expected_scales[scale_index]) >
2320            std::numeric_limits<float>::epsilon()) {
2321       ++scale_index;
2322       ASSERT_LT(scale_index, arraysize(expected_scales));
2323     }
2324
2325     EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
2326     unique_tiles.insert(tile);
2327
2328     // If the tile is the same rough bin as last tile (same activation, bin, and
2329     // scale), then distance should be decreasing.
2330     if (tile->required_for_activation() ==
2331             last_tile->required_for_activation() &&
2332         priority.priority_bin ==
2333             last_tile->priority(PENDING_TREE).priority_bin &&
2334         std::abs(tile->contents_scale() - last_tile->contents_scale()) <
2335             std::numeric_limits<float>::epsilon()) {
2336       EXPECT_LE(priority.distance_to_visible,
2337                 last_tile->priority(PENDING_TREE).distance_to_visible);
2338     }
2339
2340     last_tile = tile;
2341   }
2342
2343   EXPECT_TRUE(reached_visible);
2344   EXPECT_EQ(65u, unique_tiles.size());
2345
2346   scale_index = 0;
2347   bool reached_required = false;
2348   for (; it; ++it) {
2349     Tile* tile = *it;
2350     EXPECT_TRUE(tile);
2351
2352     TilePriority priority = tile->priority(PENDING_TREE);
2353     EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
2354
2355     if (reached_required) {
2356       EXPECT_TRUE(tile->required_for_activation());
2357     } else if (tile->required_for_activation()) {
2358       reached_required = true;
2359       scale_index = 0;
2360     }
2361
2362     while (std::abs(tile->contents_scale() - expected_scales[scale_index]) >
2363            std::numeric_limits<float>::epsilon()) {
2364       ++scale_index;
2365       ASSERT_LT(scale_index, arraysize(expected_scales));
2366     }
2367
2368     EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
2369     unique_tiles.insert(tile);
2370   }
2371
2372   EXPECT_TRUE(reached_required);
2373   EXPECT_EQ(all_tiles_set.size(), unique_tiles.size());
2374 }
2375
2376 TEST_F(PictureLayerImplTest, Occlusion) {
2377   gfx::Size tile_size(102, 102);
2378   gfx::Size layer_bounds(1000, 1000);
2379   gfx::Size viewport_size(1000, 1000);
2380
2381   LayerTestCommon::LayerImplTest impl;
2382
2383   scoped_refptr<FakePicturePileImpl> pending_pile =
2384       FakePicturePileImpl::CreateFilledPile(layer_bounds, layer_bounds);
2385   SetupPendingTree(pending_pile);
2386   pending_layer_->SetBounds(layer_bounds);
2387   ActivateTree();
2388   active_layer_->set_fixed_tile_size(tile_size);
2389
2390   host_impl_.SetViewportSize(viewport_size);
2391   host_impl_.active_tree()->UpdateDrawProperties();
2392
2393   std::vector<Tile*> tiles =
2394       active_layer_->HighResTiling()->AllTilesForTesting();
2395   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
2396
2397   {
2398     SCOPED_TRACE("No occlusion");
2399     gfx::Rect occluded;
2400     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
2401
2402     LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
2403                                                  gfx::Rect(layer_bounds));
2404     EXPECT_EQ(100u, impl.quad_list().size());
2405   }
2406
2407   {
2408     SCOPED_TRACE("Full occlusion");
2409     gfx::Rect occluded(active_layer_->visible_content_rect());
2410     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
2411
2412     LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(), gfx::Rect());
2413     EXPECT_EQ(impl.quad_list().size(), 0u);
2414   }
2415
2416   {
2417     SCOPED_TRACE("Partial occlusion");
2418     gfx::Rect occluded(150, 0, 200, 1000);
2419     impl.AppendQuadsWithOcclusion(active_layer_, occluded);
2420
2421     size_t partially_occluded_count = 0;
2422     LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
2423         impl.quad_list(),
2424         gfx::Rect(layer_bounds),
2425         occluded,
2426         &partially_occluded_count);
2427     // The layer outputs one quad, which is partially occluded.
2428     EXPECT_EQ(100u - 10u, impl.quad_list().size());
2429     EXPECT_EQ(10u + 10u, partially_occluded_count);
2430   }
2431 }
2432
2433 TEST_F(PictureLayerImplTest, RasterScaleChangeWithoutAnimation) {
2434   gfx::Size tile_size(host_impl_.settings().default_tile_size);
2435   SetupDefaultTrees(tile_size);
2436
2437   float contents_scale = 2.f;
2438   float device_scale = 1.f;
2439   float page_scale = 1.f;
2440   float maximum_animation_scale = 1.f;
2441   bool animating_transform = false;
2442
2443   SetContentsScaleOnBothLayers(contents_scale,
2444                                device_scale,
2445                                page_scale,
2446                                maximum_animation_scale,
2447                                animating_transform);
2448   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
2449
2450   // Changing the source scale without being in an animation will cause
2451   // the layer to reset its source scale to 1.f.
2452   contents_scale = 3.f;
2453
2454   SetContentsScaleOnBothLayers(contents_scale,
2455                                device_scale,
2456                                page_scale,
2457                                maximum_animation_scale,
2458                                animating_transform);
2459   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
2460
2461   // Further changes to the source scale will no longer be reflected in the
2462   // contents scale.
2463   contents_scale = 0.5f;
2464
2465   SetContentsScaleOnBothLayers(contents_scale,
2466                                device_scale,
2467                                page_scale,
2468                                maximum_animation_scale,
2469                                animating_transform);
2470   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
2471 }
2472
2473 TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
2474   gfx::Size tile_size(100, 100);
2475   gfx::Size layer_bounds(1000, 1000);
2476
2477   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
2478
2479   // Make sure some tiles are not shared.
2480   pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
2481
2482   CreateHighLowResAndSetAllTilesVisible();
2483   active_layer_->SetAllTilesReady();
2484   pending_layer_->MarkVisibleResourcesAsRequired();
2485
2486   // All pending layer tiles required are not ready.
2487   EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
2488
2489   // Initialize all low-res tiles.
2490   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->LowResTiling());
2491
2492   // Low-res tiles should not be enough.
2493   EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
2494
2495   // Initialize remaining tiles.
2496   pending_layer_->SetAllTilesReady();
2497
2498   EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
2499 }
2500
2501 TEST_F(PictureLayerImplTest, HighResReadyToDrawNotEnoughToActivate) {
2502   gfx::Size tile_size(100, 100);
2503   gfx::Size layer_bounds(1000, 1000);
2504
2505   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
2506
2507   // Make sure some tiles are not shared.
2508   pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
2509
2510   CreateHighLowResAndSetAllTilesVisible();
2511   active_layer_->SetAllTilesReady();
2512   pending_layer_->MarkVisibleResourcesAsRequired();
2513
2514   // All pending layer tiles required are not ready.
2515   EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
2516
2517   // Initialize all high-res tiles.
2518   pending_layer_->SetAllTilesReadyInTiling(pending_layer_->HighResTiling());
2519
2520   // High-res tiles should not be enough.
2521   EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
2522
2523   // Initialize remaining tiles.
2524   pending_layer_->SetAllTilesReady();
2525
2526   EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
2527 }
2528
2529 class NoLowResTilingsSettings : public ImplSidePaintingSettings {
2530  public:
2531   NoLowResTilingsSettings() { create_low_res_tiling = false; }
2532 };
2533
2534 class NoLowResPictureLayerImplTest : public PictureLayerImplTest {
2535  public:
2536   NoLowResPictureLayerImplTest()
2537       : PictureLayerImplTest(NoLowResTilingsSettings()) {}
2538 };
2539
2540 TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
2541   gfx::Size tile_size(400, 400);
2542   gfx::Size layer_bounds(1300, 1900);
2543
2544   scoped_refptr<FakePicturePileImpl> pending_pile =
2545       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2546   scoped_refptr<FakePicturePileImpl> active_pile =
2547       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2548
2549   SetupTrees(pending_pile, active_pile);
2550   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
2551
2552   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
2553   EXPECT_LT(low_res_factor, 1.f);
2554
2555   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
2556                                     6.f,  // ideal contents scale
2557                                     3.f,  // device scale
2558                                     2.f,  // page scale
2559                                     1.f,  // maximum animation scale
2560                                     false);
2561   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
2562   EXPECT_FLOAT_EQ(6.f,
2563                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
2564
2565   // If we change the page scale factor, then we should get new tilings.
2566   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
2567                                     6.6f,  // ideal contents scale
2568                                     3.f,   // device scale
2569                                     2.2f,  // page scale
2570                                     1.f,   // maximum animation scale
2571                                     false);
2572   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
2573   EXPECT_FLOAT_EQ(6.6f,
2574                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
2575
2576   // If we change the device scale factor, then we should get new tilings.
2577   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
2578                                     7.26f,  // ideal contents scale
2579                                     3.3f,   // device scale
2580                                     2.2f,   // page scale
2581                                     1.f,    // maximum animation scale
2582                                     false);
2583   ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
2584   EXPECT_FLOAT_EQ(7.26f,
2585                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
2586
2587   // If we change the device scale factor, but end up at the same total scale
2588   // factor somehow, then we don't get new tilings.
2589   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
2590                                     7.26f,  // ideal contents scale
2591                                     2.2f,   // device scale
2592                                     3.3f,   // page scale
2593                                     1.f,    // maximum animation scale
2594                                     false);
2595   ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
2596   EXPECT_FLOAT_EQ(7.26f,
2597                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
2598 }
2599
2600 TEST_F(NoLowResPictureLayerImplTest, MarkRequiredNullTiles) {
2601   gfx::Size tile_size(100, 100);
2602   gfx::Size layer_bounds(1000, 1000);
2603
2604   scoped_refptr<FakePicturePileImpl> pending_pile =
2605       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
2606   // Layers with entirely empty piles can't get tilings.
2607   pending_pile->AddRecordingAt(0, 0);
2608
2609   SetupPendingTree(pending_pile);
2610
2611   ASSERT_TRUE(pending_layer_->CanHaveTilings());
2612   pending_layer_->AddTiling(1.0f);
2613   pending_layer_->AddTiling(2.0f);
2614
2615   // It should be safe to call this (and MarkVisibleResourcesAsRequired)
2616   // on a layer with no recordings.
2617   host_impl_.pending_tree()->UpdateDrawProperties();
2618   pending_layer_->MarkVisibleResourcesAsRequired();
2619 }
2620
2621 TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfAllHighResTilesShared) {
2622   gfx::Size layer_bounds(400, 400);
2623   gfx::Size tile_size(100, 100);
2624   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
2625
2626   CreateHighLowResAndSetAllTilesVisible();
2627
2628   Tile* some_active_tile =
2629       active_layer_->HighResTiling()->AllTilesForTesting()[0];
2630   EXPECT_FALSE(some_active_tile->IsReadyToDraw());
2631
2632   // All tiles shared (no invalidation), so even though the active tree's
2633   // tiles aren't ready, there is nothing required.
2634   pending_layer_->MarkVisibleResourcesAsRequired();
2635   AssertNoTilesRequired(pending_layer_->HighResTiling());
2636   if (host_impl_.settings().create_low_res_tiling) {
2637     AssertNoTilesRequired(pending_layer_->LowResTiling());
2638   }
2639 }
2640
2641 TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
2642   gfx::Size layer_bounds(400, 400);
2643   gfx::Size tile_size(100, 100);
2644   scoped_refptr<FakePicturePileImpl> pending_pile =
2645       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2646   // This pile will create tilings, but has no recordings so will not create any
2647   // tiles.  This is attempting to simulate scrolling past the end of recorded
2648   // content on the active layer, where the recordings are so far away that
2649   // no tiles are created.
2650   scoped_refptr<FakePicturePileImpl> active_pile =
2651       FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
2652           tile_size, layer_bounds);
2653   SetupTrees(pending_pile, active_pile);
2654   pending_layer_->set_fixed_tile_size(tile_size);
2655   active_layer_->set_fixed_tile_size(tile_size);
2656
2657   CreateHighLowResAndSetAllTilesVisible();
2658
2659   // Active layer has tilings, but no tiles due to missing recordings.
2660   EXPECT_TRUE(active_layer_->CanHaveTilings());
2661   EXPECT_EQ(active_layer_->tilings()->num_tilings(),
2662             host_impl_.settings().create_low_res_tiling ? 2u : 1u);
2663   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
2664
2665   // Since the active layer has no tiles at all, the pending layer doesn't
2666   // need content in order to activate.
2667   pending_layer_->MarkVisibleResourcesAsRequired();
2668   AssertNoTilesRequired(pending_layer_->HighResTiling());
2669   if (host_impl_.settings().create_low_res_tiling)
2670     AssertNoTilesRequired(pending_layer_->LowResTiling());
2671 }
2672
2673 TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
2674   base::TimeTicks time_ticks;
2675   time_ticks += base::TimeDelta::FromMilliseconds(1);
2676   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
2677
2678   gfx::Size tile_size(100, 100);
2679   gfx::Size layer_bounds(400, 400);
2680
2681   scoped_refptr<FakePicturePileImpl> pending_pile =
2682       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2683   scoped_refptr<FakePicturePileImpl> active_pile =
2684       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2685
2686   SetupTrees(pending_pile, active_pile);
2687
2688   Region invalidation;
2689   AddDefaultTilingsWithInvalidation(invalidation);
2690   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
2691
2692   // UpdateTiles with valid viewport. Should update tile viewport.
2693   // Note viewport is considered invalid if and only if in resourceless
2694   // software draw.
2695   bool resourceless_software_draw = false;
2696   gfx::Rect viewport = gfx::Rect(layer_bounds);
2697   gfx::Transform transform;
2698   host_impl_.SetExternalDrawConstraints(transform,
2699                                         viewport,
2700                                         viewport,
2701                                         viewport,
2702                                         transform,
2703                                         resourceless_software_draw);
2704   active_layer_->draw_properties().visible_content_rect = viewport;
2705   active_layer_->draw_properties().screen_space_transform = transform;
2706   active_layer_->UpdateTiles(NULL);
2707
2708   gfx::Rect visible_rect_for_tile_priority =
2709       active_layer_->visible_rect_for_tile_priority();
2710   EXPECT_FALSE(visible_rect_for_tile_priority.IsEmpty());
2711   gfx::Rect viewport_rect_for_tile_priority =
2712       active_layer_->viewport_rect_for_tile_priority();
2713   EXPECT_FALSE(viewport_rect_for_tile_priority.IsEmpty());
2714   gfx::Transform screen_space_transform_for_tile_priority =
2715       active_layer_->screen_space_transform_for_tile_priority();
2716
2717   // Expand viewport and set it as invalid for prioritizing tiles.
2718   // Should not update tile viewport.
2719   time_ticks += base::TimeDelta::FromMilliseconds(200);
2720   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
2721   resourceless_software_draw = true;
2722   viewport = gfx::ScaleToEnclosingRect(viewport, 2);
2723   transform.Translate(1.f, 1.f);
2724   active_layer_->draw_properties().visible_content_rect = viewport;
2725   active_layer_->draw_properties().screen_space_transform = transform;
2726   host_impl_.SetExternalDrawConstraints(transform,
2727                                         viewport,
2728                                         viewport,
2729                                         viewport,
2730                                         transform,
2731                                         resourceless_software_draw);
2732   active_layer_->UpdateTiles(NULL);
2733
2734   EXPECT_RECT_EQ(visible_rect_for_tile_priority,
2735                  active_layer_->visible_rect_for_tile_priority());
2736   EXPECT_RECT_EQ(viewport_rect_for_tile_priority,
2737                  active_layer_->viewport_rect_for_tile_priority());
2738   EXPECT_TRANSFORMATION_MATRIX_EQ(
2739       screen_space_transform_for_tile_priority,
2740       active_layer_->screen_space_transform_for_tile_priority());
2741
2742   // Keep expanded viewport but mark it valid. Should update tile viewport.
2743   time_ticks += base::TimeDelta::FromMilliseconds(200);
2744   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
2745   resourceless_software_draw = false;
2746   host_impl_.SetExternalDrawConstraints(transform,
2747                                         viewport,
2748                                         viewport,
2749                                         viewport,
2750                                         transform,
2751                                         resourceless_software_draw);
2752   active_layer_->UpdateTiles(NULL);
2753
2754   EXPECT_FALSE(visible_rect_for_tile_priority ==
2755                active_layer_->visible_rect_for_tile_priority());
2756   EXPECT_FALSE(viewport_rect_for_tile_priority ==
2757                active_layer_->viewport_rect_for_tile_priority());
2758   EXPECT_FALSE(screen_space_transform_for_tile_priority ==
2759                active_layer_->screen_space_transform_for_tile_priority());
2760 }
2761
2762 TEST_F(NoLowResPictureLayerImplTest, InvalidViewportAfterReleaseResources) {
2763   gfx::Size tile_size(100, 100);
2764   gfx::Size layer_bounds(400, 400);
2765
2766   scoped_refptr<FakePicturePileImpl> pending_pile =
2767       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2768   scoped_refptr<FakePicturePileImpl> active_pile =
2769       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2770
2771   SetupTrees(pending_pile, active_pile);
2772
2773   Region invalidation;
2774   AddDefaultTilingsWithInvalidation(invalidation);
2775
2776   bool resourceless_software_draw = true;
2777   gfx::Rect viewport = gfx::Rect(layer_bounds);
2778   gfx::Transform identity = gfx::Transform();
2779   host_impl_.SetExternalDrawConstraints(identity,
2780                                         viewport,
2781                                         viewport,
2782                                         viewport,
2783                                         identity,
2784                                         resourceless_software_draw);
2785   ResetTilingsAndRasterScales();
2786   host_impl_.pending_tree()->UpdateDrawProperties();
2787   host_impl_.active_tree()->UpdateDrawProperties();
2788   EXPECT_TRUE(active_layer_->HighResTiling());
2789
2790   size_t num_tilings = active_layer_->num_tilings();
2791   active_layer_->UpdateTiles(NULL);
2792   pending_layer_->AddTiling(0.5f);
2793   EXPECT_EQ(num_tilings + 1, active_layer_->num_tilings());
2794 }
2795
2796 TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
2797   gfx::Size tile_size(400, 400);
2798   gfx::Size layer_bounds(1300, 1900);
2799
2800   scoped_refptr<FakePicturePileImpl> pending_pile =
2801       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2802   scoped_refptr<FakePicturePileImpl> active_pile =
2803       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2804
2805   std::vector<PictureLayerTiling*> used_tilings;
2806
2807   SetupTrees(pending_pile, active_pile);
2808   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
2809
2810   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
2811   EXPECT_LT(low_res_factor, 1.f);
2812
2813   float device_scale = 1.7f;
2814   float page_scale = 3.2f;
2815   float scale = 1.f;
2816
2817   SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
2818   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
2819
2820   // We only have ideal tilings, so they aren't removed.
2821   used_tilings.clear();
2822   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2823   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
2824
2825   host_impl_.PinchGestureBegin();
2826
2827   // Changing the ideal but not creating new tilings.
2828   scale *= 1.5f;
2829   page_scale *= 1.5f;
2830   SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
2831   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
2832
2833   // The tilings are still our target scale, so they aren't removed.
2834   used_tilings.clear();
2835   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2836   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
2837
2838   host_impl_.PinchGestureEnd();
2839
2840   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
2841   scale /= 4.f;
2842   page_scale /= 4.f;
2843   SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, false);
2844   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
2845   EXPECT_FLOAT_EQ(1.f,
2846                   active_layer_->tilings()->tiling_at(1)->contents_scale());
2847
2848   // Mark the non-ideal tilings as used. They won't be removed.
2849   used_tilings.clear();
2850   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
2851   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2852   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
2853
2854   // Now move the ideal scale to 0.5. Our target stays 1.2.
2855   SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.f, false);
2856
2857   // The high resolution tiling is between target and ideal, so is not
2858   // removed.  The low res tiling for the old ideal=1.0 scale is removed.
2859   used_tilings.clear();
2860   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2861   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
2862
2863   // Now move the ideal scale to 1.0. Our target stays 1.2.
2864   SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
2865
2866   // All the tilings are between are target and the ideal, so they are not
2867   // removed.
2868   used_tilings.clear();
2869   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2870   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
2871
2872   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
2873   SetupDrawPropertiesAndUpdateTiles(
2874       active_layer_, 1.1f, device_scale, page_scale, 1.f, false);
2875
2876   // Because the pending layer's ideal scale is still 1.0, our tilings fall
2877   // in the range [1.0,1.2] and are kept.
2878   used_tilings.clear();
2879   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2880   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
2881
2882   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
2883   // 1.2 still.
2884   SetupDrawPropertiesAndUpdateTiles(
2885       pending_layer_, 1.1f, device_scale, page_scale, 1.f, false);
2886
2887   // Our 1.0 tiling now falls outside the range between our ideal scale and our
2888   // target raster scale. But it is in our used tilings set, so nothing is
2889   // deleted.
2890   used_tilings.clear();
2891   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
2892   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2893   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
2894
2895   // If we remove it from our used tilings set, it is outside the range to keep
2896   // so it is deleted.
2897   used_tilings.clear();
2898   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2899   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
2900 }
2901
2902 TEST_F(PictureLayerImplTest, ScaleCollision) {
2903   gfx::Size tile_size(400, 400);
2904   gfx::Size layer_bounds(1300, 1900);
2905
2906   scoped_refptr<FakePicturePileImpl> pending_pile =
2907       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2908   scoped_refptr<FakePicturePileImpl> active_pile =
2909       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2910
2911   std::vector<PictureLayerTiling*> used_tilings;
2912
2913   SetupTrees(pending_pile, active_pile);
2914
2915   float pending_contents_scale = 1.f;
2916   float active_contents_scale = 2.f;
2917   float device_scale_factor = 1.f;
2918   float page_scale_factor = 1.f;
2919   float maximum_animation_contents_scale = 1.f;
2920   bool animating_transform = false;
2921
2922   EXPECT_TRUE(host_impl_.settings().create_low_res_tiling);
2923   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
2924   EXPECT_LT(low_res_factor, 1.f);
2925
2926   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
2927                                     pending_contents_scale,
2928                                     device_scale_factor,
2929                                     page_scale_factor,
2930                                     maximum_animation_contents_scale,
2931                                     animating_transform);
2932   SetupDrawPropertiesAndUpdateTiles(active_layer_,
2933                                     active_contents_scale,
2934                                     device_scale_factor,
2935                                     page_scale_factor,
2936                                     maximum_animation_contents_scale,
2937                                     animating_transform);
2938
2939   ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
2940   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
2941
2942   EXPECT_EQ(active_contents_scale,
2943             pending_layer_->tilings()->tiling_at(0)->contents_scale());
2944   EXPECT_EQ(pending_contents_scale,
2945             pending_layer_->tilings()->tiling_at(1)->contents_scale());
2946   EXPECT_EQ(active_contents_scale * low_res_factor,
2947             pending_layer_->tilings()->tiling_at(2)->contents_scale());
2948   EXPECT_EQ(pending_contents_scale * low_res_factor,
2949             pending_layer_->tilings()->tiling_at(3)->contents_scale());
2950
2951   EXPECT_EQ(active_contents_scale,
2952             active_layer_->tilings()->tiling_at(0)->contents_scale());
2953   EXPECT_EQ(pending_contents_scale,
2954             active_layer_->tilings()->tiling_at(1)->contents_scale());
2955   EXPECT_EQ(active_contents_scale * low_res_factor,
2956             active_layer_->tilings()->tiling_at(2)->contents_scale());
2957   EXPECT_EQ(pending_contents_scale * low_res_factor,
2958             active_layer_->tilings()->tiling_at(3)->contents_scale());
2959
2960   // The unused low res tiling from the pending tree must be kept or we may add
2961   // it again on the active tree and collide with the pending tree.
2962   used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
2963   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
2964   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
2965
2966   EXPECT_EQ(active_contents_scale,
2967             active_layer_->tilings()->tiling_at(0)->contents_scale());
2968   EXPECT_EQ(pending_contents_scale,
2969             active_layer_->tilings()->tiling_at(1)->contents_scale());
2970   EXPECT_EQ(active_contents_scale * low_res_factor,
2971             active_layer_->tilings()->tiling_at(2)->contents_scale());
2972   EXPECT_EQ(pending_contents_scale * low_res_factor,
2973             active_layer_->tilings()->tiling_at(3)->contents_scale());
2974 }
2975
2976 TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
2977   gfx::Size tile_size(400, 400);
2978   gfx::Size layer_bounds(1300, 1900);
2979
2980   scoped_refptr<FakePicturePileImpl> pending_pile =
2981       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2982   scoped_refptr<FakePicturePileImpl> active_pile =
2983       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
2984
2985   SetupTrees(pending_pile, active_pile);
2986   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
2987
2988   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
2989                                     1.3f,  // ideal contents scale
2990                                     2.7f,  // device scale
2991                                     3.2f,  // page scale
2992                                     1.f,   // maximum animation scale
2993                                     false);
2994   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
2995
2996   // All tilings should be removed when losing output surface.
2997   active_layer_->ReleaseResources();
2998   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
2999   pending_layer_->ReleaseResources();
3000   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
3001
3002   // This should create new tilings.
3003   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
3004                                     1.3f,  // ideal contents scale
3005                                     2.7f,  // device scale
3006                                     3.2f,  // page scale
3007                                     1.f,   // maximum animation scale
3008                                     false);
3009   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
3010 }
3011
3012 TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
3013   MockOcclusionTracker<LayerImpl> occlusion_tracker;
3014   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
3015
3016   gfx::Size tile_size(400, 400);
3017   gfx::Size layer_bounds(1000, 2000);
3018
3019   scoped_refptr<FakePicturePileImpl> pending_pile =
3020       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3021   scoped_refptr<FakePicturePileImpl> active_pile =
3022       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3023
3024   SetupTrees(pending_pile, active_pile);
3025
3026   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
3027   host_impl_.pending_tree()->UpdateDrawProperties();
3028
3029   active_layer_->draw_properties().visible_content_rect =
3030       gfx::Rect(layer_bounds);
3031   host_impl_.active_tree()->UpdateDrawProperties();
3032
3033   float max_contents_scale = active_layer_->MaximumTilingContentsScale();
3034   gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
3035   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
3036                               SK_MScalar1 / max_contents_scale);
3037
3038   AppendQuadsData data;
3039   active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
3040
3041   // SharedQuadState should have be of size 1, as we are doing AppenQuad once.
3042   EXPECT_EQ(1u, render_pass->shared_quad_state_list.size());
3043   // The content_to_target_transform should be scaled by the
3044   // MaximumTilingContentsScale on the layer.
3045   EXPECT_EQ(scaled_draw_transform.ToString(),
3046             render_pass->shared_quad_state_list[0]
3047                 ->content_to_target_transform.ToString());
3048   // The content_bounds should be scaled by the
3049   // MaximumTilingContentsScale on the layer.
3050   EXPECT_EQ(gfx::Size(2500u, 5000u).ToString(),
3051             render_pass->shared_quad_state_list[0]->content_bounds.ToString());
3052   // The visible_content_rect should be scaled by the
3053   // MaximumTilingContentsScale on the layer.
3054   EXPECT_EQ(
3055       gfx::Rect(0u, 0u, 2500u, 5000u).ToString(),
3056       render_pass->shared_quad_state_list[0]->visible_content_rect.ToString());
3057 }
3058
3059 TEST_F(PictureLayerImplTest, UpdateTilesForMasksWithNoVisibleContent) {
3060   gfx::Size tile_size(400, 400);
3061   gfx::Size bounds(100000, 100);
3062
3063   host_impl_.CreatePendingTree();
3064
3065   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.pending_tree(), 1);
3066
3067   scoped_ptr<FakePictureLayerImpl> layer_with_mask =
3068       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 2);
3069
3070   layer_with_mask->SetBounds(bounds);
3071   layer_with_mask->SetContentBounds(bounds);
3072
3073   scoped_refptr<FakePicturePileImpl> pending_pile =
3074       FakePicturePileImpl::CreateFilledPile(tile_size, bounds);
3075   scoped_ptr<FakePictureLayerImpl> mask = FakePictureLayerImpl::CreateWithPile(
3076       host_impl_.pending_tree(), 3, pending_pile);
3077
3078   mask->SetIsMask(true);
3079   mask->SetBounds(bounds);
3080   mask->SetContentBounds(bounds);
3081   mask->SetDrawsContent(true);
3082
3083   FakePictureLayerImpl* pending_mask_content = mask.get();
3084   layer_with_mask->SetMaskLayer(mask.PassAs<LayerImpl>());
3085
3086   scoped_ptr<FakePictureLayerImpl> child_of_layer_with_mask =
3087       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 4);
3088
3089   child_of_layer_with_mask->SetBounds(bounds);
3090   child_of_layer_with_mask->SetContentBounds(bounds);
3091   child_of_layer_with_mask->SetDrawsContent(true);
3092
3093   layer_with_mask->AddChild(child_of_layer_with_mask.PassAs<LayerImpl>());
3094
3095   root->AddChild(layer_with_mask.PassAs<LayerImpl>());
3096
3097   host_impl_.pending_tree()->SetRootLayer(root.Pass());
3098
3099   EXPECT_FALSE(pending_mask_content->tilings());
3100   host_impl_.pending_tree()->UpdateDrawProperties();
3101   EXPECT_NE(0u, pending_mask_content->num_tilings());
3102 }
3103
3104 class OcclusionTrackingSettings : public ImplSidePaintingSettings {
3105  public:
3106   OcclusionTrackingSettings() { use_occlusion_for_tile_prioritization = true; }
3107 };
3108
3109 class OcclusionTrackingPictureLayerImplTest : public PictureLayerImplTest {
3110  public:
3111   OcclusionTrackingPictureLayerImplTest()
3112       : PictureLayerImplTest(OcclusionTrackingSettings()) {}
3113
3114   void VerifyEvictionConsidersOcclusion(
3115       PictureLayerImpl* layer,
3116       size_t expected_occluded_tile_count[NUM_TREE_PRIORITIES]) {
3117     for (int priority_count = 0; priority_count < NUM_TREE_PRIORITIES;
3118          ++priority_count) {
3119       TreePriority tree_priority = static_cast<TreePriority>(priority_count);
3120       size_t occluded_tile_count = 0u;
3121       Tile* last_tile = NULL;
3122
3123       for (PictureLayerImpl::LayerEvictionTileIterator it =
3124                PictureLayerImpl::LayerEvictionTileIterator(layer,
3125                                                            tree_priority);
3126            it;
3127            ++it) {
3128         Tile* tile = *it;
3129         if (!last_tile)
3130           last_tile = tile;
3131
3132         // The only way we will encounter an occluded tile after an unoccluded
3133         // tile is if the priorty bin decreased, the tile is required for
3134         // activation, or the scale changed.
3135         bool tile_is_occluded =
3136             tile->is_occluded_for_tree_priority(tree_priority);
3137         if (tile_is_occluded) {
3138           occluded_tile_count++;
3139
3140           bool last_tile_is_occluded =
3141               last_tile->is_occluded_for_tree_priority(tree_priority);
3142           if (!last_tile_is_occluded) {
3143             TilePriority::PriorityBin tile_priority_bin =
3144                 tile->priority_for_tree_priority(tree_priority).priority_bin;
3145             TilePriority::PriorityBin last_tile_priority_bin =
3146                 last_tile->priority_for_tree_priority(tree_priority)
3147                     .priority_bin;
3148
3149             EXPECT_TRUE(
3150                 (tile_priority_bin < last_tile_priority_bin) ||
3151                 tile->required_for_activation() ||
3152                 (tile->contents_scale() != last_tile->contents_scale()));
3153           }
3154         }
3155         last_tile = tile;
3156       }
3157       EXPECT_EQ(expected_occluded_tile_count[priority_count],
3158                 occluded_tile_count);
3159     }
3160   }
3161 };
3162
3163 TEST_F(OcclusionTrackingPictureLayerImplTest,
3164        OccludedTilesSkippedDuringRasterization) {
3165   base::TimeTicks time_ticks;
3166   time_ticks += base::TimeDelta::FromMilliseconds(1);
3167   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
3168
3169   gfx::Size tile_size(102, 102);
3170   gfx::Size layer_bounds(1000, 1000);
3171   gfx::Size viewport_size(500, 500);
3172   gfx::Point occluding_layer_position(310, 0);
3173
3174   scoped_refptr<FakePicturePileImpl> pending_pile =
3175       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3176   SetupPendingTree(pending_pile);
3177   pending_layer_->set_fixed_tile_size(tile_size);
3178
3179   host_impl_.SetViewportSize(viewport_size);
3180   host_impl_.pending_tree()->UpdateDrawProperties();
3181
3182   // No occlusion.
3183   int unoccluded_tile_count = 0;
3184   for (PictureLayerImpl::LayerRasterTileIterator it =
3185            PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
3186        it;
3187        ++it) {
3188     Tile* tile = *it;
3189
3190     // Occluded tiles should not be iterated over.
3191     EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
3192
3193     // Some tiles may not be visible (i.e. outside the viewport). The rest are
3194     // visible and at least partially unoccluded, verified by the above expect.
3195     bool tile_is_visible =
3196         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
3197     if (tile_is_visible)
3198       unoccluded_tile_count++;
3199   }
3200   EXPECT_EQ(unoccluded_tile_count, 25 + 4);
3201
3202   // Partial occlusion.
3203   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
3204   LayerImpl* layer1 = pending_layer_->children()[0];
3205   layer1->SetBounds(layer_bounds);
3206   layer1->SetContentBounds(layer_bounds);
3207   layer1->SetDrawsContent(true);
3208   layer1->SetContentsOpaque(true);
3209   layer1->SetPosition(occluding_layer_position);
3210
3211   time_ticks += base::TimeDelta::FromMilliseconds(200);
3212   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
3213   host_impl_.pending_tree()->UpdateDrawProperties();
3214
3215   unoccluded_tile_count = 0;
3216   for (PictureLayerImpl::LayerRasterTileIterator it =
3217            PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
3218        it;
3219        ++it) {
3220     Tile* tile = *it;
3221
3222     EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
3223
3224     bool tile_is_visible =
3225         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
3226     if (tile_is_visible)
3227       unoccluded_tile_count++;
3228   }
3229   EXPECT_EQ(unoccluded_tile_count, 20 + 2);
3230
3231   // Full occlusion.
3232   layer1->SetPosition(gfx::Point(0, 0));
3233
3234   time_ticks += base::TimeDelta::FromMilliseconds(200);
3235   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
3236   host_impl_.pending_tree()->UpdateDrawProperties();
3237
3238   unoccluded_tile_count = 0;
3239   for (PictureLayerImpl::LayerRasterTileIterator it =
3240            PictureLayerImpl::LayerRasterTileIterator(pending_layer_, false);
3241        it;
3242        ++it) {
3243     Tile* tile = *it;
3244
3245     EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
3246
3247     bool tile_is_visible =
3248         tile->content_rect().Intersects(pending_layer_->visible_content_rect());
3249     if (tile_is_visible)
3250       unoccluded_tile_count++;
3251   }
3252   EXPECT_EQ(unoccluded_tile_count, 0);
3253 }
3254
3255 TEST_F(OcclusionTrackingPictureLayerImplTest,
3256        OccludedTilesNotMarkedAsRequired) {
3257   base::TimeTicks time_ticks;
3258   time_ticks += base::TimeDelta::FromMilliseconds(1);
3259   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
3260
3261   gfx::Size tile_size(102, 102);
3262   gfx::Size layer_bounds(1000, 1000);
3263   gfx::Size viewport_size(500, 500);
3264   gfx::Point occluding_layer_position(310, 0);
3265
3266   scoped_refptr<FakePicturePileImpl> pending_pile =
3267       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3268   SetupPendingTree(pending_pile);
3269   pending_layer_->set_fixed_tile_size(tile_size);
3270
3271   host_impl_.SetViewportSize(viewport_size);
3272   host_impl_.pending_tree()->UpdateDrawProperties();
3273
3274   // No occlusion.
3275   int occluded_tile_count = 0;
3276   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
3277     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
3278
3279     occluded_tile_count = 0;
3280     for (PictureLayerTiling::CoverageIterator iter(
3281              tiling,
3282              pending_layer_->contents_scale_x(),
3283              gfx::Rect(layer_bounds));
3284          iter;
3285          ++iter) {
3286       if (!*iter)
3287         continue;
3288       const Tile* tile = *iter;
3289
3290       // Fully occluded tiles are not required for activation.
3291       if (tile->is_occluded(PENDING_TREE)) {
3292         EXPECT_FALSE(tile->required_for_activation());
3293         occluded_tile_count++;
3294       }
3295     }
3296     EXPECT_EQ(occluded_tile_count, 0);
3297   }
3298
3299   // Partial occlusion.
3300   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
3301   LayerImpl* layer1 = pending_layer_->children()[0];
3302   layer1->SetBounds(layer_bounds);
3303   layer1->SetContentBounds(layer_bounds);
3304   layer1->SetDrawsContent(true);
3305   layer1->SetContentsOpaque(true);
3306   layer1->SetPosition(occluding_layer_position);
3307
3308   time_ticks += base::TimeDelta::FromMilliseconds(200);
3309   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
3310   host_impl_.pending_tree()->UpdateDrawProperties();
3311
3312   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
3313     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
3314
3315     occluded_tile_count = 0;
3316     for (PictureLayerTiling::CoverageIterator iter(
3317              tiling,
3318              pending_layer_->contents_scale_x(),
3319              gfx::Rect(layer_bounds));
3320          iter;
3321          ++iter) {
3322       if (!*iter)
3323         continue;
3324       const Tile* tile = *iter;
3325
3326       if (tile->is_occluded(PENDING_TREE)) {
3327         EXPECT_FALSE(tile->required_for_activation());
3328         occluded_tile_count++;
3329       }
3330     }
3331     switch (i) {
3332       case 0:
3333         EXPECT_EQ(occluded_tile_count, 5);
3334         break;
3335       case 1:
3336         EXPECT_EQ(occluded_tile_count, 2);
3337         break;
3338       default:
3339         NOTREACHED();
3340     }
3341   }
3342
3343   // Full occlusion.
3344   layer1->SetPosition(gfx::PointF(0, 0));
3345
3346   time_ticks += base::TimeDelta::FromMilliseconds(200);
3347   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
3348   host_impl_.pending_tree()->UpdateDrawProperties();
3349
3350   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
3351     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
3352
3353     occluded_tile_count = 0;
3354     for (PictureLayerTiling::CoverageIterator iter(
3355              tiling,
3356              pending_layer_->contents_scale_x(),
3357              gfx::Rect(layer_bounds));
3358          iter;
3359          ++iter) {
3360       if (!*iter)
3361         continue;
3362       const Tile* tile = *iter;
3363
3364       if (tile->is_occluded(PENDING_TREE)) {
3365         EXPECT_FALSE(tile->required_for_activation());
3366         occluded_tile_count++;
3367       }
3368     }
3369     switch (i) {
3370       case 0:
3371         EXPECT_EQ(occluded_tile_count, 25);
3372         break;
3373       case 1:
3374         EXPECT_EQ(occluded_tile_count, 4);
3375         break;
3376       default:
3377         NOTREACHED();
3378     }
3379   }
3380 }
3381
3382 TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
3383   gfx::Size tile_size(102, 102);
3384   gfx::Size layer_bounds(1000, 1000);
3385   gfx::Size viewport_size(500, 500);
3386   gfx::Point occluding_layer_position(310, 0);
3387
3388   scoped_refptr<FakePicturePileImpl> pending_pile =
3389       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3390   SetupPendingTree(pending_pile);
3391   pending_layer_->set_fixed_tile_size(tile_size);
3392
3393   ASSERT_TRUE(pending_layer_->CanHaveTilings());
3394
3395   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
3396
3397   std::vector<PictureLayerTiling*> tilings;
3398   tilings.push_back(pending_layer_->AddTiling(low_res_factor));
3399   tilings.push_back(pending_layer_->AddTiling(0.3f));
3400   tilings.push_back(pending_layer_->AddTiling(0.7f));
3401   tilings.push_back(pending_layer_->AddTiling(1.0f));
3402   tilings.push_back(pending_layer_->AddTiling(2.0f));
3403
3404   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
3405   LayerImpl* layer1 = pending_layer_->children()[0];
3406   layer1->SetBounds(layer_bounds);
3407   layer1->SetContentBounds(layer_bounds);
3408   layer1->SetDrawsContent(true);
3409   layer1->SetContentsOpaque(true);
3410   layer1->SetPosition(occluding_layer_position);
3411
3412   host_impl_.SetViewportSize(viewport_size);
3413   host_impl_.pending_tree()->UpdateDrawProperties();
3414
3415   int tiling_count = 0;
3416   int occluded_tile_count = 0;
3417   for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
3418            tilings.begin();
3419        tiling_iterator != tilings.end();
3420        ++tiling_iterator) {
3421     std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
3422
3423     occluded_tile_count = 0;
3424     for (size_t i = 0; i < tiles.size(); ++i) {
3425       if (tiles[i]->is_occluded(PENDING_TREE)) {
3426         gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
3427             tiles[i]->content_rect(), 1.0f / tiles[i]->contents_scale());
3428         EXPECT_GE(scaled_content_rect.x(), occluding_layer_position.x());
3429         occluded_tile_count++;
3430       }
3431     }
3432     switch (tiling_count) {
3433       case 0:
3434       case 1:
3435         EXPECT_EQ(occluded_tile_count, 2);
3436         break;
3437       case 2:
3438         EXPECT_EQ(occluded_tile_count, 4);
3439         break;
3440       case 3:
3441         EXPECT_EQ(occluded_tile_count, 5);
3442         break;
3443       case 4:
3444         EXPECT_EQ(occluded_tile_count, 30);
3445         break;
3446       default:
3447         NOTREACHED();
3448     }
3449
3450     tiling_count++;
3451   }
3452
3453   EXPECT_EQ(tiling_count, 5);
3454 }
3455
3456 TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
3457   gfx::Size tile_size(102, 102);
3458   gfx::Size layer_bounds(1000, 1000);
3459   gfx::Size viewport_size(1000, 1000);
3460   gfx::Point occluding_layer_position(310, 0);
3461   gfx::Rect invalidation_rect(230, 230, 102, 102);
3462
3463   scoped_refptr<FakePicturePileImpl> pending_pile =
3464       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3465   scoped_refptr<FakePicturePileImpl> active_pile =
3466       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3467   SetupTrees(pending_pile, active_pile);
3468
3469   // Partially occlude the active layer.
3470   active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
3471   LayerImpl* layer1 = active_layer_->children()[0];
3472   layer1->SetBounds(layer_bounds);
3473   layer1->SetContentBounds(layer_bounds);
3474   layer1->SetDrawsContent(true);
3475   layer1->SetContentsOpaque(true);
3476   layer1->SetPosition(occluding_layer_position);
3477
3478   // Partially invalidate the pending layer.
3479   pending_layer_->set_invalidation(invalidation_rect);
3480
3481   host_impl_.SetViewportSize(viewport_size);
3482
3483   active_layer_->CreateDefaultTilingsAndTiles();
3484   pending_layer_->CreateDefaultTilingsAndTiles();
3485
3486   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
3487     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
3488
3489     for (PictureLayerTiling::CoverageIterator iter(
3490              tiling,
3491              pending_layer_->contents_scale_x(),
3492              gfx::Rect(layer_bounds));
3493          iter;
3494          ++iter) {
3495       if (!*iter)
3496         continue;
3497       const Tile* tile = *iter;
3498
3499       // All tiles are unoccluded on the pending tree.
3500       EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
3501
3502       Tile* twin_tile =
3503           pending_layer_->GetTwinTiling(tiling)->TileAt(iter.i(), iter.j());
3504       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
3505           tile->content_rect(), 1.0f / tile->contents_scale());
3506
3507       if (scaled_content_rect.Intersects(invalidation_rect)) {
3508         // Tiles inside the invalidation rect are only on the pending tree.
3509         EXPECT_NE(tile, twin_tile);
3510
3511         // Unshared tiles should be unoccluded on the active tree by default.
3512         EXPECT_FALSE(tile->is_occluded(ACTIVE_TREE));
3513       } else {
3514         // Tiles outside the invalidation rect are shared between both trees.
3515         EXPECT_EQ(tile, twin_tile);
3516         // Shared tiles are occluded on the active tree iff they lie beneath the
3517         // occluding layer.
3518         EXPECT_EQ(tile->is_occluded(ACTIVE_TREE),
3519                   scaled_content_rect.x() >= occluding_layer_position.x());
3520       }
3521     }
3522   }
3523
3524   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
3525     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
3526
3527     for (PictureLayerTiling::CoverageIterator iter(
3528              tiling,
3529              active_layer_->contents_scale_x(),
3530              gfx::Rect(layer_bounds));
3531          iter;
3532          ++iter) {
3533       if (!*iter)
3534         continue;
3535       const Tile* tile = *iter;
3536
3537       Tile* twin_tile =
3538           active_layer_->GetTwinTiling(tiling)->TileAt(iter.i(), iter.j());
3539       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
3540           tile->content_rect(), 1.0f / tile->contents_scale());
3541
3542       // Since we've already checked the shared tiles, only consider tiles in
3543       // the invalidation rect.
3544       if (scaled_content_rect.Intersects(invalidation_rect)) {
3545         // Tiles inside the invalidation rect are only on the active tree.
3546         EXPECT_NE(tile, twin_tile);
3547
3548         // Unshared tiles should be unoccluded on the pending tree by default.
3549         EXPECT_FALSE(tile->is_occluded(PENDING_TREE));
3550
3551         // Unshared tiles are occluded on the active tree iff they lie beneath
3552         // the occluding layer.
3553         EXPECT_EQ(tile->is_occluded(ACTIVE_TREE),
3554                   scaled_content_rect.x() >= occluding_layer_position.x());
3555       }
3556     }
3557   }
3558 }
3559
3560 TEST_F(OcclusionTrackingPictureLayerImplTest,
3561        OccludedTilesConsideredDuringEviction) {
3562   gfx::Size tile_size(102, 102);
3563   gfx::Size layer_bounds(1000, 1000);
3564   gfx::Size viewport_size(500, 500);
3565   gfx::Point pending_occluding_layer_position(310, 0);
3566   gfx::Point active_occluding_layer_position(0, 310);
3567   gfx::Rect invalidation_rect(230, 230, 102, 102);
3568
3569   scoped_refptr<FakePicturePileImpl> pending_pile =
3570       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3571   scoped_refptr<FakePicturePileImpl> active_pile =
3572       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
3573   SetupTrees(pending_pile, active_pile);
3574
3575   pending_layer_->set_fixed_tile_size(tile_size);
3576   active_layer_->set_fixed_tile_size(tile_size);
3577
3578   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
3579
3580   std::vector<PictureLayerTiling*> tilings;
3581   tilings.push_back(pending_layer_->AddTiling(low_res_factor));
3582   tilings.push_back(pending_layer_->AddTiling(0.3f));
3583   tilings.push_back(pending_layer_->AddTiling(0.7f));
3584   tilings.push_back(pending_layer_->AddTiling(1.0f));
3585   tilings.push_back(pending_layer_->AddTiling(2.0f));
3586
3587   EXPECT_EQ(5u, pending_layer_->num_tilings());
3588   EXPECT_EQ(5u, active_layer_->num_tilings());
3589
3590   // Partially occlude the pending layer.
3591   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
3592   LayerImpl* pending_occluding_layer = pending_layer_->children()[0];
3593   pending_occluding_layer->SetBounds(layer_bounds);
3594   pending_occluding_layer->SetContentBounds(layer_bounds);
3595   pending_occluding_layer->SetDrawsContent(true);
3596   pending_occluding_layer->SetContentsOpaque(true);
3597   pending_occluding_layer->SetPosition(pending_occluding_layer_position);
3598
3599   // Partially occlude the active layer.
3600   active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
3601   LayerImpl* active_occluding_layer = active_layer_->children()[0];
3602   active_occluding_layer->SetBounds(layer_bounds);
3603   active_occluding_layer->SetContentBounds(layer_bounds);
3604   active_occluding_layer->SetDrawsContent(true);
3605   active_occluding_layer->SetContentsOpaque(true);
3606   active_occluding_layer->SetPosition(active_occluding_layer_position);
3607
3608   // Partially invalidate the pending layer. Tiles inside the invalidation rect
3609   // are not shared between trees.
3610   pending_layer_->set_invalidation(invalidation_rect);
3611
3612   host_impl_.SetViewportSize(viewport_size);
3613   host_impl_.active_tree()->UpdateDrawProperties();
3614   host_impl_.pending_tree()->UpdateDrawProperties();
3615
3616   // The expected number of occluded tiles on each of the 5 tilings for each of
3617   // the 3 tree priorities.
3618   size_t expected_occluded_tile_count_on_both[] = {9u, 1u, 1u, 1u, 1u};
3619   size_t expected_occluded_tile_count_on_active[] = {30u, 5u, 4u, 2u, 2u};
3620   size_t expected_occluded_tile_count_on_pending[] = {30u, 5u, 4u, 2u, 2u};
3621
3622   // The total expected number of occluded tiles on all tilings for each of the
3623   // 3 tree priorities.
3624   size_t total_expected_occluded_tile_count[] = {13u, 43u, 43u};
3625
3626   ASSERT_EQ(arraysize(total_expected_occluded_tile_count), NUM_TREE_PRIORITIES);
3627
3628   // Verify number of occluded tiles on the pending layer for each tiling.
3629   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
3630     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
3631     tiling->CreateAllTilesForTesting();
3632
3633     size_t occluded_tile_count_on_pending = 0u;
3634     size_t occluded_tile_count_on_active = 0u;
3635     size_t occluded_tile_count_on_both = 0u;
3636     for (PictureLayerTiling::CoverageIterator iter(
3637              tiling,
3638              pending_layer_->contents_scale_x(),
3639              gfx::Rect(layer_bounds));
3640          iter;
3641          ++iter) {
3642       Tile* tile = *iter;
3643
3644       if (tile->is_occluded(PENDING_TREE))
3645         occluded_tile_count_on_pending++;
3646       if (tile->is_occluded(ACTIVE_TREE))
3647         occluded_tile_count_on_active++;
3648       if (tile->is_occluded(PENDING_TREE) && tile->is_occluded(ACTIVE_TREE))
3649         occluded_tile_count_on_both++;
3650     }
3651     EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
3652               occluded_tile_count_on_pending)
3653         << i;
3654     EXPECT_EQ(expected_occluded_tile_count_on_active[i],
3655               occluded_tile_count_on_active)
3656         << i;
3657     EXPECT_EQ(expected_occluded_tile_count_on_both[i],
3658               occluded_tile_count_on_both)
3659         << i;
3660   }
3661
3662   // Verify number of occluded tiles on the active layer for each tiling.
3663   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
3664     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
3665     tiling->CreateAllTilesForTesting();
3666
3667     size_t occluded_tile_count_on_pending = 0u;
3668     size_t occluded_tile_count_on_active = 0u;
3669     size_t occluded_tile_count_on_both = 0u;
3670     for (PictureLayerTiling::CoverageIterator iter(
3671              tiling,
3672              pending_layer_->contents_scale_x(),
3673              gfx::Rect(layer_bounds));
3674          iter;
3675          ++iter) {
3676       Tile* tile = *iter;
3677
3678       if (tile->is_occluded(PENDING_TREE))
3679         occluded_tile_count_on_pending++;
3680       if (tile->is_occluded(ACTIVE_TREE))
3681         occluded_tile_count_on_active++;
3682       if (tile->is_occluded(PENDING_TREE) && tile->is_occluded(ACTIVE_TREE))
3683         occluded_tile_count_on_both++;
3684     }
3685     EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
3686               occluded_tile_count_on_pending)
3687         << i;
3688     EXPECT_EQ(expected_occluded_tile_count_on_active[i],
3689               occluded_tile_count_on_active)
3690         << i;
3691     EXPECT_EQ(expected_occluded_tile_count_on_both[i],
3692               occluded_tile_count_on_both)
3693         << i;
3694   }
3695
3696   std::vector<Tile*> all_tiles;
3697   for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
3698            tilings.begin();
3699        tiling_iterator != tilings.end();
3700        ++tiling_iterator) {
3701     std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
3702     std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
3703   }
3704
3705   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
3706
3707   VerifyEvictionConsidersOcclusion(pending_layer_,
3708                                    total_expected_occluded_tile_count);
3709   VerifyEvictionConsidersOcclusion(active_layer_,
3710                                    total_expected_occluded_tile_count);
3711 }
3712 }  // namespace
3713 }  // namespace cc