cc: Give TilingData a Rect instead of a Size

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/picture_layer_impl.h"
 
 #include <set>
 #include <utility>
 
 #include "cc/layers/append_quads_data.h"
@@ skipping 57 matching lines @@
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {
     gfx::Size tile_size(100, 100);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-    SetupTrees(pending_pile, active_pile);
+    SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   }
 
   void ActivateTree() {
     host_impl_.ActivatePendingTree();
     CHECK(!host_impl_.pending_tree());
     pending_layer_ = NULL;
     active_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.active_tree()->LayerById(id_));
   }
 
   void SetupDefaultTreesWithFixedTileSize(const gfx::Size& layer_bounds,
                                           const gfx::Size& tile_size) {
     SetupDefaultTrees(layer_bounds);
     pending_layer_->set_fixed_tile_size(tile_size);
     active_layer_->set_fixed_tile_size(tile_size);
   }
 
   void SetupTrees(
       scoped_refptr<PicturePileImpl> pending_pile,
-      scoped_refptr<PicturePileImpl> active_pile) {
-    SetupPendingTree(active_pile);
+      scoped_refptr<PicturePileImpl> active_pile,
+      const gfx::Size& pending_layer_bounds,
+      const gfx::Size& active_layer_bounds) {
+    SetupPendingTree(active_pile, active_layer_bounds);
     ActivateTree();
-    SetupPendingTree(pending_pile);
+    SetupPendingTree(pending_pile, pending_layer_bounds);
   }
 
   void CreateHighLowResAndSetAllTilesVisible() {
     // Active layer must get updated first so pending layer can share from it.
     active_layer_->CreateDefaultTilingsAndTiles();
     active_layer_->SetAllTilesVisible();
     pending_layer_->CreateDefaultTilingsAndTiles();
     pending_layer_->SetAllTilesVisible();
   }
 
   void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
     active_layer_->AddTiling(2.3f);
     active_layer_->AddTiling(1.0f);
     active_layer_->AddTiling(0.5f);
     for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i)
       active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
     pending_layer_->set_invalidation(invalidation);
     for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i)
       pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
   }
 
   void SetupPendingTree(
-      scoped_refptr<PicturePileImpl> pile) {
+      scoped_refptr<PicturePileImpl> pile, const gfx::Size& layer_bounds) {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     // Clear recycled tree.
     pending_tree->DetachLayerTree();
 
     scoped_ptr<FakePictureLayerImpl> pending_layer =
-        FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
+        FakePictureLayerImpl::CreateWithPile(
+            pending_tree, id_, pile, layer_bounds);

[enne (OOO), 2014/04/11 20:19:51]

Maybe don't add another parameter here, and just make the bounds equal to the
pile size? Alternatively, a rect containing the origin and the pile rect?

[ernstm, 2014/04/11 23:43:51]

Done. Added a separate CreateWithPartialPile for piles that don't cover the
entire layer (for new tests).

     pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::CoverageIterator
-             iter(tiling, tiling->contents_scale(), tiling->ContentRect());
+             iter(tiling, tiling->contents_scale(), tiling->TilingRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
@@ skipping 43 matching lines @@
     ImplSidePaintingSettings settings;
     gfx::Size layer_size(
         settings.default_tile_size.width() * 7 / 2,
         settings.default_tile_size.height() * 7 / 2);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 
-    SetupTrees(pending_pile, active_pile);
+    SetupTrees(pending_pile, active_pile, layer_size, layer_size);
 
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
     active_layer_->CalculateContentsScale(
         1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
     // Add 1x1 rects at the centers of each tile, then re-record pile contents
     active_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
     std::vector<Tile*> tiles =
         active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
@@ skipping 49 matching lines @@
 
 TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
             active_layer_->tilings()->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i)
     VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), active_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, TileManagerRegisterUnregister) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   std::vector<TileManager::PairedPictureLayer> paired_layers;
   host_impl_.tile_manager()->GetPairedPictureLayers(&paired_layers);
   EXPECT_EQ(0u, paired_layers.size());
 
   // Update tile priorities will force the layer to register itself.
   float dummy_contents_scale_x;
   float dummy_contents_scale_y;
   gfx::Size dummy_content_bounds;
   active_layer_->CalculateContentsScale(1.f,
@@ skipping 58 matching lines @@
   host_impl_.SetCurrentFrameTimeTicks(time_ticks);
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
   float dummy_contents_scale_x;
   float dummy_contents_scale_y;
   gfx::Size dummy_content_bounds;
   active_layer_->CalculateContentsScale(1.f,
                                         1.f,
                                         1.f,
                                         false,
@@ skipping 33 matching lines @@
 TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   Region invalidation(layer_invalidation);
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
         layer_invalidation,
         tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
-                  tiling->ContentRect());
+                  tiling->TilingRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
         EXPECT_EQ(pending_pile, iter->picture_pile());
       else
         EXPECT_EQ(active_pile, iter->picture_pile());
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   gfx::Size tile_size(90, 80);
   gfx::Size layer_bounds(300, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   Region invalidation((gfx::Rect(layer_bounds)));
   AddDefaultTilingsWithInvalidation(invalidation);
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
             active_layer_->tilings()->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i)
     VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
   gfx::Size tile_size(90, 80);
   gfx::Size active_layer_bounds(300, 500);
   gfx::Size pending_layer_bounds(400, 800);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size,
                                                 pending_layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile,
+             active_layer_bounds, pending_layer_bounds);
   pending_layer_->set_fixed_tile_size(gfx::Size(100, 100));
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     gfx::Rect active_content_bounds = gfx::ScaleToEnclosingRect(
         gfx::Rect(active_layer_bounds),
         tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
-                  tiling->ContentRect());
+                  tiling->TilingRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       std::vector<Tile*> active_tiles =
           active_layer_->tilings()->tiling_at(i)->AllTilesForTesting();
       std::vector<Tile*> pending_tiles = tiling->AllTilesForTesting();
       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
           iter.geometry_rect().bottom() >= active_content_bounds.height() ||
           active_tiles[0]->content_rect().size() !=
@@ skipping 23 matching lines @@
         pending_pile->AddRecordingAt(x, y);
         active_pile->AddRecordingAt(x, y);
       } else {
         hole_count++;
         if (hole_count % 2)
           pending_pile->AddRecordingAt(x, y);
       }
     }
   }
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
 
     for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
-                  tiling->ContentRect());
+                  tiling->TilingRect());
          iter;
          ++iter) {
       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
       // Ensure there is a recording for this tile.
       bool in_pending = pending_pile->CanRaster(tiling->contents_scale(),
                                                 iter.full_tile_geometry_rect());
       bool in_active = active_pile->CanRaster(tiling->contents_scale(),
                                               iter.full_tile_geometry_rect());
 
       if (in_pending && !in_active)
@@ skipping 11 matching lines @@
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   pending_layer_->CalculateContentsScale(
       1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          1.7f,  // device scale
                                          3.2f,  // page cale
                                          false,
                                          &result_scale_x,
@@ skipping 89 matching lines @@
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float high_res_scale = 1.3f;
   float low_res_scale = high_res_scale * low_res_factor;
   float device_scale = 1.7f;
   float page_scale = 3.2f;
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
-  SetupPendingTree(valid_pile);
+  SetupPendingTree(valid_pile, layer_bounds);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
   EXPECT_FLOAT_EQ(low_res_scale,
                   pending_layer_->LowResTiling()->contents_scale());
 
   ActivateTree();
-  SetupPendingTree(empty_pile);
+  SetupPendingTree(empty_pile, layer_bounds);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
   active_layer_->CalculateContentsScale(high_res_scale,
                                         device_scale,
                                         page_scale,
                                         false,
                                         &result_scale_x,
                                         &result_scale_y,
                                         &result_bounds);
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
-  SetupPendingTree(valid_pile);
+  SetupPendingTree(valid_pile, layer_bounds);
   pending_layer_->CalculateContentsScale(high_res_scale,
                                          device_scale,
                                          page_scale,
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(high_res_scale,
                   pending_layer_->HighResTiling()->contents_scale());
   EXPECT_FLOAT_EQ(low_res_scale,
                   pending_layer_->LowResTiling()->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   // Set up the high and low res tilings before pinch zoom.
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, false);
   host_impl_.PinchGestureBegin();
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false);
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false);
   EXPECT_EQ(active_layer_->tilings()->NumHighResTilings(), 1);
 }
 
 TEST_F(PictureLayerImplTest, PinchGestureTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   // Set up the high and low res tilings before pinch zoom.
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, false);
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.0f,
       active_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.0f * low_res_factor,
       active_layer_->tilings()->tiling_at(1)->contents_scale());
@@ skipping 40 matching lines @@
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
   std::vector<PictureLayerTiling*> used_tilings;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float device_scale = 1.7f;
   float page_scale = 3.2f;
 
   SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, false);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
@@ skipping 195 matching lines @@
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(1.3f,  // ideal contents scale
                                          2.7f,  // device scale
                                          3.2f,  // page cale
                                          false,
                                          &result_scale_x,
                                          &result_scale_y,
                                          &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
@@ skipping 21 matching lines @@
   gfx::Size layer_bounds(5000, 5000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(
       1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value.
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
@@ skipping 31 matching lines @@
   gfx::Size layer_bounds(500, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->CalculateContentsScale(
       1.f, 1.f, 1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
   ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
   // The default value. The layer is smaller than this.
   EXPECT_EQ(gfx::Size(512, 512).ToString(),
@@ skipping 34 matching lines @@
   MockQuadCuller quad_culler;
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
 
   active_layer_->SetContentBounds(layer_bounds);
   active_layer_->draw_properties().visible_content_rect =
       gfx::Rect(layer_bounds);
 
   gfx::Rect layer_invalidation(150, 200, 30, 180);
   Region invalidation(layer_invalidation);
   AddDefaultTilingsWithInvalidation(invalidation);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL);
   active_layer_->AppendQuads(&quad_culler, &data);
   active_layer_->DidDraw(NULL);
 
   ASSERT_EQ(1U, quad_culler.quad_list().size());
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT, quad_culler.quad_list()[0]->material);
 }
 
 TEST_F(PictureLayerImplTest, MarkRequiredNullTiles) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   // Layers with entirely empty piles can't get tilings.
   pending_pile->AddRecordingAt(0, 0);
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_pile, layer_bounds);
 
   ASSERT_TRUE(pending_layer_->CanHaveTilings());
   pending_layer_->AddTiling(1.0f);
   pending_layer_->AddTiling(2.0f);
 
   // It should be safe to call this (and MarkVisibleResourcesAsRequired)
   // on a layer with no recordings.
   host_impl_.pending_tree()->UpdateDrawProperties();
   pending_layer_->MarkVisibleResourcesAsRequired();
 }
 
 TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_pile, layer_bounds);
 
   pending_layer_->set_fixed_tile_size(tile_size);
   ASSERT_TRUE(pending_layer_->CanHaveTilings());
   PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
   host_impl_.pending_tree()->UpdateDrawProperties();
   EXPECT_EQ(tiling->resolution(), HIGH_RESOLUTION);
 
   pending_layer_->draw_properties().visible_content_rect =
       gfx::Rect(0, 0, 100, 200);
 
@@ skipping 106 matching lines @@
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   // This pile will create tilings, but has no recordings so will not create any
   // tiles.  This is attempting to simulate scrolling past the end of recorded
   // content on the active layer, where the recordings are so far away that
   // no tiles are created.
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
           tile_size, layer_bounds);
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_EQ(active_layer_->tilings()->num_tilings(), 2u);
   EXPECT_EQ(active_layer_->HighResTiling()->AllTilesForTesting().size(), 0u);
 
   // Since the active layer has no tiles at all, the pending layer doesn't
   // need content in order to activate.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertNoTilesRequired(pending_layer_->HighResTiling());
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
-  SetupTrees(pending_pile, active_pile);
+  SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   pending_layer_->set_fixed_tile_size(tile_size);
   active_layer_->set_fixed_tile_size(tile_size);
 
   CreateHighLowResAndSetAllTilesVisible();
 
   // Active layer can't have tiles.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
 
   // All high res tiles required.  This should be considered identical
   // to the case where there is no active layer, to avoid flashing content.
   // This can happen if a layer exists for a while and switches from
   // not being able to have content to having content.
   pending_layer_->MarkVisibleResourcesAsRequired();
   AssertAllTilesRequired(pending_layer_->HighResTiling());
   AssertNoTilesRequired(pending_layer_->LowResTiling());
 }
 
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
   scoped_ptr<FakePictureLayerImpl> pending_layer =
-      FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile);
+      FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile,
+                                           layer_bounds);
   pending_layer->SetDrawsContent(true);
   pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
 
   pending_layer_ = static_cast<FakePictureLayerImpl*>(
       host_impl_.pending_tree()->LayerById(id_));
 
   // Set some state on the pending layer, make sure it is not clobbered
   // by a sync from the active layer.  This could happen because if the
   // pending layer has not been post-commit initialized it will attempt
   // to sync from the active layer.
@@ skipping 122 matching lines @@
 
     // Create some default active and pending trees.
     gfx::Size tile_size(100, 100);
     gfx::Size layer_bounds(400, 400);
 
     scoped_refptr<FakePicturePileImpl> pending_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
     scoped_refptr<FakePicturePileImpl> active_pile =
         FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-    SetupTrees(pending_pile, active_pile);
+    SetupTrees(pending_pile, active_pile, layer_bounds, layer_bounds);
   }
 };
 
 // This test is really a LayerTreeHostImpl test, in that it makes sure
 // that trees need update draw properties after deferred initialization.
 // However, this is also a regression test for PictureLayerImpl in that
 // not having this update will cause a crash.
 TEST_F(DeferredInitPictureLayerImplTest,
        PreventUpdateTilePrioritiesDuringLostContext) {
   host_impl_.pending_tree()->UpdateDrawProperties();
@@ skipping 146 matching lines @@
   ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, LayerRasterTileIterator) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_pile, layer_bounds);
 
   ASSERT_TRUE(pending_layer_->CanHaveTilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
 
   pending_layer_->AddTiling(low_res_factor);
   pending_layer_->AddTiling(0.3f);
   pending_layer_->AddTiling(0.7f);
   PictureLayerTiling* high_res_tiling = pending_layer_->AddTiling(1.0f);
   pending_layer_->AddTiling(2.0f);
@@ skipping 67 matching lines @@
     high_res_tile_count += priority.resolution == HIGH_RESOLUTION;
   }
 
   EXPECT_EQ(0u, non_ideal_tile_count);
   EXPECT_EQ(1u, low_res_tile_count);
   EXPECT_EQ(0u, high_res_tile_count);
 }
 
 }  // namespace
 }  // namespace cc