cc: Don't swap PictureLayerTilingSet on activate.

When activating, create new tilings on the active tree and make new
shared tiles. This way we don't have tilings on the recycle tree from
two frames ago, and the path which data travels is much more clear.

BUG=387116

Review URL: https://codereview.chromium.org/640063010

Cr-Commit-Position: refs/heads/master@{#307816}

1 files changed, 887 insertions, 1035 deletions

diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 90a36f7..b9d3060 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -34,6 +34,18 @@
 namespace cc {
 namespace {
 
+#define EXPECT_BOTH_EQ(expression, x)         \
+  do {                                        \
+    EXPECT_EQ(x, pending_layer_->expression); \
+    EXPECT_EQ(x, active_layer_->expression);  \
+  } while (false)
+
+#define EXPECT_BOTH_NE(expression, x)         \
+  do {                                        \
+    EXPECT_NE(x, pending_layer_->expression); \
+    EXPECT_NE(x, active_layer_->expression);  \
+  } while (false)
+
 class MockCanvas : public SkCanvas {
  public:
   explicit MockCanvas(int w, int h) : SkCanvas(w, h) {}
@@ -58,15 +70,21 @@ class PictureLayerImplTest : public testing::Test {
   PictureLayerImplTest()
       : proxy_(base::MessageLoopProxy::current()),
         host_impl_(LowResTilingsSettings(), &proxy_, &shared_bitmap_manager_),
+        root_id_(6),
         id_(7),
         pending_layer_(nullptr),
         old_pending_layer_(nullptr),
-        active_layer_(nullptr) {}
+        active_layer_(nullptr) {
+    host_impl_.SetViewportSize(gfx::Size(10000, 10000));
+  }
 
   explicit PictureLayerImplTest(const LayerTreeSettings& settings)
       : proxy_(base::MessageLoopProxy::current()),
         host_impl_(settings, &proxy_, &shared_bitmap_manager_),
-        id_(7) {}
+        root_id_(6),
+        id_(7) {
+    host_impl_.SetViewportSize(gfx::Size(10000, 10000));
+  }
 
   virtual ~PictureLayerImplTest() {
   }
@@ -88,6 +106,18 @@ class PictureLayerImplTest : public testing::Test {
     SetupTrees(pending_pile, active_pile);
   }
 
+  void SetupDefaultTreesWithInvalidation(const gfx::Size& layer_bounds,
+                                         const Region& invalidation) {
+    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);
+
+    SetupTreesWithInvalidation(pending_pile, active_pile, invalidation);
+  }
+
   void ActivateTree() {
     host_impl_.ActivateSyncTree();
     CHECK(!host_impl_.pending_tree());
@@ -96,13 +126,22 @@ class PictureLayerImplTest : public testing::Test {
     pending_layer_ = nullptr;
     active_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.active_tree()->LayerById(id_));
+
+    host_impl_.active_tree()->UpdateDrawProperties();
   }
 
   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);
+                                          const gfx::Size& tile_size,
+                                          const Region& invalidation) {
+    gfx::Size pile_tile_size(100, 100);
+
+    scoped_refptr<FakePicturePileImpl> pending_pile =
+        FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_bounds);
+    scoped_refptr<FakePicturePileImpl> active_pile =
+        FakePicturePileImpl::CreateFilledPile(pile_tile_size, layer_bounds);
+
+    SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size,
+                                invalidation);
   }
 
   void SetupTrees(
@@ -110,54 +149,80 @@ class PictureLayerImplTest : public testing::Test {
       scoped_refptr<PicturePileImpl> active_pile) {
     SetupPendingTree(active_pile);
     ActivateTree();
-    SetupPendingTree(pending_pile);
+    SetupPendingTreeInternal(pending_pile, gfx::Size(), Region());
   }
 
-  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 SetupTreesWithInvalidation(scoped_refptr<PicturePileImpl> pending_pile,
+                                  scoped_refptr<PicturePileImpl> active_pile,
+                                  const Region& pending_invalidation) {
+    SetupPendingTreeInternal(active_pile, gfx::Size(), Region());
+    ActivateTree();
+    SetupPendingTreeInternal(pending_pile, gfx::Size(), pending_invalidation);
   }
 
-  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 SetupTreesWithFixedTileSize(scoped_refptr<PicturePileImpl> pending_pile,
+                                   scoped_refptr<PicturePileImpl> active_pile,
+                                   const gfx::Size& tile_size,
+                                   const Region& pending_invalidation) {
+    SetupPendingTreeInternal(active_pile, tile_size, Region());
+    ActivateTree();
+    SetupPendingTreeInternal(pending_pile, tile_size, pending_invalidation);
   }
 
   void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
+    SetupPendingTreeInternal(raster_source, gfx::Size(), Region());
+  }
+
+  void SetupPendingTreeWithInvalidation(
+      scoped_refptr<RasterSource> raster_source,
+      const Region& invalidation) {
+    SetupPendingTreeInternal(raster_source, gfx::Size(), invalidation);
+  }
+
+  void SetupPendingTreeWithFixedTileSize(
+      scoped_refptr<RasterSource> raster_source,
+      const gfx::Size& tile_size,
+      const Region& invalidation) {
+    SetupPendingTreeInternal(raster_source, tile_size, invalidation);
+  }
+
+  void SetupPendingTreeInternal(scoped_refptr<RasterSource> raster_source,
+                                const gfx::Size& tile_size,
+                                const Region& invalidation) {
     host_impl_.CreatePendingTree();
     host_impl_.pending_tree()->PushPageScaleFromMainThread(1.f, 0.25f, 100.f);
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
-    // Steal from the recycled tree.
-    scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
-    DCHECK_IMPLIES(old_pending_root, old_pending_root->id() == id_);
-
+    // Steal from the recycled tree if possible.
+    scoped_ptr<LayerImpl> pending_root = pending_tree->DetachLayerTree();
     scoped_ptr<FakePictureLayerImpl> pending_layer;
-    if (old_pending_root) {
-      pending_layer.reset(
-          static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
-      pending_layer->SetRasterSource(raster_source);
-    } else {
-      pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
-          pending_tree, id_, raster_source);
+    DCHECK_IMPLIES(pending_root, pending_root->id() == root_id_);
+    if (!pending_root) {
+      pending_root = LayerImpl::Create(pending_tree, root_id_);
+      pending_layer = FakePictureLayerImpl::Create(pending_tree, id_);
+      if (!tile_size.IsEmpty())
+        pending_layer->set_fixed_tile_size(tile_size);
       pending_layer->SetDrawsContent(true);
+    } else {
+      pending_layer.reset(static_cast<FakePictureLayerImpl*>(
+          pending_root->RemoveChild(pending_root->children()[0]).release()));
+      if (!tile_size.IsEmpty())
+        pending_layer->set_fixed_tile_size(tile_size);
     }
     // The bounds() just mirror the pile size.
-    pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-    pending_tree->SetRootLayer(pending_layer.Pass());
+    pending_layer->SetBounds(raster_source->GetSize());
+    pending_layer->SetContentBounds(raster_source->GetSize());
+    pending_layer->SetRasterSourceOnPending(raster_source, invalidation);
+
+    pending_root->AddChild(pending_layer.Pass());
+    pending_tree->SetRootLayer(pending_root.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
+
+    // Add tilings/tiles for the layer.
+    host_impl_.pending_tree()->UpdateDrawProperties();
   }
 
   void SetupDrawPropertiesAndUpdateTiles(FakePictureLayerImpl* layer,
@@ -213,6 +278,10 @@ class PictureLayerImplTest : public testing::Test {
   void ResetTilingsAndRasterScales() {
     pending_layer_->ReleaseResources();
     active_layer_->ReleaseResources();
+    if (pending_layer_)
+      EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+    if (active_layer_)
+      EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   }
 
   void AssertAllTilesRequired(PictureLayerTiling* tiling) {
@@ -230,60 +299,12 @@ class PictureLayerImplTest : public testing::Test {
   }
 
  protected:
-  void TestTileGridAlignmentCommon() {
-    // Layer to span 4 raster tiles in x and in y
-    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);
-
-    SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
-
-    // 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();
-    EXPECT_EQ(16u, tiles.size());
-    std::vector<SkRect> rects;
-    std::vector<Tile*>::const_iterator tile_iter;
-    for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
-      gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
-      gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
-      active_pile->add_draw_rect(rect);
-      rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
-    }
-    // Force re-record with newly injected content
-    active_pile->RemoveRecordingAt(0, 0);
-    active_pile->AddRecordingAt(0, 0);
-
-    std::vector<SkRect>::const_iterator rect_iter = rects.begin();
-    for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
-      MockCanvas mock_canvas(1000, 1000);
-      active_pile->PlaybackToSharedCanvas(&mock_canvas,
-                                          (*tile_iter)->content_rect(), 1.0f);
-
-      // This test verifies that when drawing the contents of a specific tile
-      // at content scale 1.0, the playback canvas never receives content from
-      // neighboring tiles which indicates that the tile grid embedded in
-      // SkPicture is perfectly aligned with the compositor's tiles.
-      EXPECT_EQ(1u, mock_canvas.rects_.size());
-      EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
-      rect_iter++;
-    }
-  }
-
   void TestQuadsForSolidColor(bool test_for_solid);
 
   FakeImplProxy proxy_;
   TestSharedBitmapManager shared_bitmap_manager_;
   FakeLayerTreeHostImpl host_impl_;
+  int root_id_;
   int id_;
   FakePictureLayerImpl* pending_layer_;
   FakePictureLayerImpl* old_pending_layer_;
@@ -293,14 +314,56 @@ class PictureLayerImplTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 };
 
+class NoLowResPictureLayerImplTest : public PictureLayerImplTest {
+ public:
+  NoLowResPictureLayerImplTest()
+      : PictureLayerImplTest(NoLowResTilingsSettings()) {}
+};
+
 TEST_F(PictureLayerImplTest, TileGridAlignment) {
-  host_impl_.SetDeviceScaleFactor(1.f);
-  TestTileGridAlignmentCommon();
-}
+  // Layer to span 4 raster tiles in x and in y
+  ImplSidePaintingSettings settings;
+  gfx::Size layer_size(settings.default_tile_size.width() * 7 / 2,
+                       settings.default_tile_size.height() * 7 / 2);
 
-TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) {
-  host_impl_.SetDeviceScaleFactor(2.f);
-  TestTileGridAlignmentCommon();
+  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);
+
+  // 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();
+  EXPECT_EQ(16u, tiles.size());
+  std::vector<SkRect> rects;
+  std::vector<Tile*>::const_iterator tile_iter;
+  for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
+    gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
+    gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
+    active_pile->add_draw_rect(rect);
+    rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
+  }
+  // Force re-raster with newly injected content
+  active_pile->RemoveRecordingAt(0, 0);
+  active_pile->AddRecordingAt(0, 0);
+
+  std::vector<SkRect>::const_iterator rect_iter = rects.begin();
+  for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
+    MockCanvas mock_canvas(1000, 1000);
+    active_pile->PlaybackToSharedCanvas(&mock_canvas,
+                                        (*tile_iter)->content_rect(), 1.0f);
+
+    // This test verifies that when drawing the contents of a specific tile
+    // at content scale 1.0, the playback canvas never receives content from
+    // neighboring tiles which indicates that the tile grid embedded in
+    // SkPicture is perfectly aligned with the compositor's tiles.
+    EXPECT_EQ(1u, mock_canvas.rects_.size());
+    EXPECT_EQ(*rect_iter, mock_canvas.rects_[0]);
+    rect_iter++;
+  }
 }
 
 TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
@@ -312,10 +375,7 @@ TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
-
-  Region invalidation;
-  AddDefaultTilingsWithInvalidation(invalidation);
+  SetupTreesWithInvalidation(pending_pile, active_pile, Region());
 
   EXPECT_EQ(pending_layer_->tilings()->num_tilings(),
             active_layer_->tilings()->num_tilings());
@@ -323,7 +383,7 @@ TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   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());
+    VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
@@ -339,10 +399,8 @@ TEST_F(PictureLayerImplTest, ExternalViewportRectForPrioritizingTiles) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTreesWithInvalidation(pending_pile, active_pile, Region());
 
-  Region invalidation;
-  AddDefaultTilingsWithInvalidation(invalidation);
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   time_ticks += base::TimeDelta::FromMilliseconds(200);
@@ -436,10 +494,8 @@ TEST_F(PictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTreesWithInvalidation(pending_pile, active_pile, Region());
 
-  Region invalidation;
-  AddDefaultTilingsWithInvalidation(invalidation);
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   // UpdateTiles with valid viewport. Should update tile viewport.
@@ -516,11 +572,20 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> lost_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupPendingTreeWithFixedTileSize(lost_pile, gfx::Size(50, 50), Region());
+  ActivateTree();
+  // Add a non-shared tiling on the active tree.
+  PictureLayerTiling* tiling = active_layer_->AddTiling(3.f);
+  tiling->CreateAllTilesForTesting();
+  // Then setup a new pending tree and activate it.
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, gfx::Size(50, 50),
+                              layer_invalidation);
 
-  Region invalidation(layer_invalidation);
-  AddDefaultTilingsWithInvalidation(invalidation);
+  EXPECT_EQ(2u, pending_layer_->num_tilings());
+  EXPECT_EQ(3u, active_layer_->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer_->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
@@ -537,61 +602,16 @@ TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
-      if (iter.geometry_rect().Intersects(content_invalidation))
-        EXPECT_EQ(pending_pile.get(), iter->raster_source());
-      else
-        EXPECT_EQ(active_pile.get(), iter->raster_source());
+      EXPECT_EQ(pending_pile.get(), iter->raster_source());
     }
   }
-}
 
-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);
-
-  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);
-  pending_layer_->set_fixed_tile_size(gfx::Size(100, 100));
-
-  Region invalidation;
-  AddDefaultTilingsWithInvalidation(invalidation);
-
-  const PictureLayerTilingSet* tilings = pending_layer_->tilings();
+  tilings = active_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());
+    gfx::Rect content_invalidation =
+        gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
@@ -600,94 +620,108 @@ TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
          ++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() !=
-              pending_tiles[0]->content_rect().size()) {
-        EXPECT_EQ(pending_pile.get(), iter->raster_source());
-      } else {
+      if (iter.geometry_rect().Intersects(content_invalidation))
         EXPECT_EQ(active_pile.get(), iter->raster_source());
-      }
+      else if (!active_layer_->GetPendingOrActiveTwinTiling(tiling))
+        EXPECT_EQ(active_pile.get(), iter->raster_source());
+      else
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
     }
   }
 }
 
-TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
-  gfx::Size tile_size(400, 400);
-  gfx::Size layer_bounds(1300, 1900);
+TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
+  gfx::Size tile_size(90, 80);
+  gfx::Size layer_bounds(300, 500);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  // Fill in some of active pile, but more of pending pile.
-  int hole_count = 0;
-  for (int x = 0; x < active_pile->tiling().num_tiles_x(); ++x) {
-    for (int y = 0; y < active_pile->tiling().num_tiles_y(); ++y) {
-      if ((x + y) % 2) {
-        pending_pile->AddRecordingAt(x, y);
-        active_pile->AddRecordingAt(x, y);
-      } else {
-        hole_count++;
-        if (hole_count % 2)
-          pending_pile->AddRecordingAt(x, y);
-      }
-    }
-  }
+  SetupTreesWithInvalidation(pending_pile, active_pile,
+                             gfx::Rect(layer_bounds));
 
-  SetupTrees(pending_pile, active_pile);
-  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) {
-    const PictureLayerTiling* tiling = tilings->tiling_at(i);
-
-    for (PictureLayerTiling::CoverageIterator iter(
-             tiling,
-             tiling->contents_scale(),
-             gfx::Rect(tiling->tiling_size()));
-         iter;
-         ++iter) {
-      EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
-      // Ensure there is a recording for this tile.
-      bool in_pending = pending_pile->CoversRect(iter.full_tile_geometry_rect(),
-                                                 tiling->contents_scale());
-      bool in_active = active_pile->CoversRect(iter.full_tile_geometry_rect(),
-                                               tiling->contents_scale());
-
-      if (in_pending && !in_active)
-        EXPECT_EQ(pending_pile.get(), iter->raster_source());
-      else if (in_active)
-        EXPECT_EQ(active_pile.get(), iter->raster_source());
-      else
-        EXPECT_FALSE(*iter);
-    }
-  }
+  for (size_t i = 0; i < tilings->num_tilings(); ++i)
+    VerifyAllTilesExistAndHavePile(tilings->tiling_at(i), pending_pile.get());
 }
 
-TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
+TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
+  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+  EXPECT_LT(low_res_factor, 1.f);
 
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+  active_layer_->ReleaseResources();
+  EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
+
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    6.f,  // ideal contents scale
+                                    3.f,  // device scale
+                                    2.f,  // page scale
+                                    1.f,  // maximum animation scale
+                                    false);
+  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(6.f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(6.f * low_res_factor,
+                  active_layer_->tilings()->tiling_at(1)->contents_scale());
+
+  // If we change the page scale factor, then we should get new tilings.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    6.6f,  // ideal contents scale
+                                    3.f,   // device scale
+                                    2.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
+  ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(6.6f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(6.6f * low_res_factor,
+                  active_layer_->tilings()->tiling_at(2)->contents_scale());
+
+  // If we change the device scale factor, then we should get new tilings.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    7.26f,  // ideal contents scale
+                                    3.3f,   // device scale
+                                    2.2f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
+  ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(7.26f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(7.26f * low_res_factor,
+                  active_layer_->tilings()->tiling_at(3)->contents_scale());
+
+  // If we change the device scale factor, but end up at the same total scale
+  // factor somehow, then we don't get new tilings.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    7.26f,  // ideal contents scale
+                                    2.2f,   // device scale
+                                    3.3f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
+  ASSERT_EQ(6u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(7.26f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(7.26f * low_res_factor,
+                  active_layer_->tilings()->tiling_at(3)->contents_scale());
 }
 
-TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
+TEST_F(PictureLayerImplTest, PendingLayerOnlyHasHighAndLowResTiling) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
@@ -697,11 +731,13 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  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_->ReleaseResources();
+  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
+
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
@@ -721,11 +757,11 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
                                     2.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     false);
-  ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.6f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(6.6f * low_res_factor,
-                  pending_layer_->tilings()->tiling_at(2)->contents_scale());
+                  pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the device scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
@@ -734,11 +770,11 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
                                     2.2f,   // page scale
                                     1.f,    // maximum animation scale
                                     false);
-  ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
-                  pending_layer_->tilings()->tiling_at(3)->contents_scale());
+                  pending_layer_->tilings()->tiling_at(1)->contents_scale());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
@@ -748,11 +784,11 @@ TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     false);
-  ASSERT_EQ(6u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(7.26f * low_res_factor,
-                  pending_layer_->tilings()->tiling_at(3)->contents_scale());
+                  pending_layer_->tilings()->tiling_at(1)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
@@ -767,63 +803,22 @@ TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  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 maximum_animation_scale = 1.f;
-
   SetupPendingTree(valid_pile);
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    high_res_scale,
-                                    device_scale,
-                                    page_scale,
-                                    maximum_animation_scale,
-                                    false);
   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);
   EXPECT_FALSE(pending_layer_->CanHaveTilings());
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    high_res_scale,
-                                    device_scale,
-                                    page_scale,
-                                    maximum_animation_scale,
-                                    false);
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
   ASSERT_EQ(0u, pending_layer_->tilings()->num_tilings());
 
   ActivateTree();
   EXPECT_FALSE(active_layer_->CanHaveTilings());
-  SetupDrawPropertiesAndUpdateTiles(active_layer_,
-                                    high_res_scale,
-                                    device_scale,
-                                    page_scale,
-                                    maximum_animation_scale,
-                                    false);
   ASSERT_EQ(0u, active_layer_->tilings()->num_tilings());
 
   SetupPendingTree(valid_pile);
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    high_res_scale,
-                                    device_scale,
-                                    page_scale,
-                                    maximum_animation_scale,
-                                    false);
   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) {
@@ -837,8 +832,10 @@ TEST_F(PictureLayerImplTest, ZoomOutCrash) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
+  ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, 1.0f, false);
+  EXPECT_EQ(32.f, active_layer_->HighResTiling()->contents_scale());
   host_impl_.PinchGestureBegin();
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, false);
@@ -849,6 +846,8 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
+  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
@@ -856,21 +855,20 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
 
   // Set up the high and low res tilings before pinch zoom.
   SetupTrees(pending_pile, active_pile);
-  EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
-  SetContentsScaleOnBothLayers(2.0f, 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(2.0f,
-                  active_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(2.0f * low_res_factor,
-                  active_layer_->tilings()->tiling_at(1)->contents_scale());
+  ResetTilingsAndRasterScales();
+
+  SetContentsScaleOnBothLayers(2.f, 1.0f, 2.f, 1.0f, false);
+  EXPECT_BOTH_EQ(num_tilings(), 2u);
+  EXPECT_BOTH_EQ(tilings()->tiling_at(0)->contents_scale(), 2.f);
+  EXPECT_BOTH_EQ(tilings()->tiling_at(1)->contents_scale(),
+                 2.f * low_res_factor);
 
   // Start a pinch gesture.
   host_impl_.PinchGestureBegin();
 
   // Zoom out by a small amount. We should create a tiling at half
   // the scale (2/kMaxScaleRatioDuringPinch).
-  SetContentsScaleOnBothLayers(1.8f, 1.0f, 0.9f, 1.0f, false);
+  SetContentsScaleOnBothLayers(1.8f, 1.0f, 1.8f, 1.0f, false);
   EXPECT_EQ(3u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(2.0f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -887,7 +885,7 @@ TEST_F(PictureLayerImplTest, PinchGestureTilings) {
 
   // Zoom in a lot now. Since we increase by increments of
   // kMaxScaleRatioDuringPinch, this will create a new tiling at 4.0.
-  SetContentsScaleOnBothLayers(3.8f, 1.0f, 2.1f, 1.f, false);
+  SetContentsScaleOnBothLayers(3.8f, 1.0f, 3.8f, 1.f, false);
   EXPECT_EQ(4u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(4.0f,
                   active_layer_->tilings()->tiling_at(0)->contents_scale());
@@ -902,9 +900,12 @@ TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
   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);
+
+  ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
+
+  // Set up the high and low res tilings before pinch zoom.
   SetContentsScaleOnBothLayers(0.24f, 1.0f, 0.24f, 1.0f, false);
   EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(0.24f,
@@ -955,31 +956,28 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
 
   std::vector<PictureLayerTiling*> used_tilings;
 
-  SetupTrees(pending_pile, active_pile);
-  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;
   float scale = 1.f;
+  float page_scale = 1.f;
 
-  SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  SetupTrees(pending_pile, active_pile);
+  EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
+  EXPECT_EQ(1.f, active_layer_->HighResTiling()->contents_scale());
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   host_impl_.PinchGestureBegin();
 
   // Changing the ideal but not creating new tilings.
-  scale *= 1.5f;
-  page_scale *= 1.5f;
-  SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
-  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  scale = 1.5f;
+  page_scale = 1.5f;
+  SetContentsScaleOnBothLayers(scale, 1.f, page_scale, 1.f, false);
+  EXPECT_EQ(2u, active_layer_->tilings()->num_tilings());
 
   // The tilings are still our target scale, so they aren't removed.
   used_tilings.clear();
@@ -989,9 +987,9 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   host_impl_.PinchGestureEnd();
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
-  scale /= 4.f;
-  page_scale /= 4.f;
-  SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, false);
+  scale = 1.2f;
+  page_scale = 1.2f;
+  SetContentsScaleOnBothLayers(1.2f, 1.f, page_scale, 1.f, false);
   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(
       1.f,
@@ -1008,7 +1006,7 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 0.5. Our target stays 1.2.
-  SetContentsScaleOnBothLayers(0.5f, device_scale, page_scale, 1.f, false);
+  SetContentsScaleOnBothLayers(0.5f, 1.f, page_scale, 1.f, false);
 
   // The high resolution tiling is between target and ideal, so is not
   // removed.  The low res tiling for the old ideal=1.0 scale is removed.
@@ -1017,7 +1015,7 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.0. Our target stays 1.2.
-  SetContentsScaleOnBothLayers(1.f, device_scale, page_scale, 1.f, false);
+  SetContentsScaleOnBothLayers(1.f, 1.f, page_scale, 1.f, false);
 
   // All the tilings are between are target and the ideal, so they are not
   // removed.
@@ -1026,8 +1024,8 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
-  SetupDrawPropertiesAndUpdateTiles(
-      active_layer_, 1.1f, device_scale, page_scale, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.1f, 1.f, page_scale, 1.f,
+                                    false);
 
   // Because the pending layer's ideal scale is still 1.0, our tilings fall
   // in the range [1.0,1.2] and are kept.
@@ -1037,8 +1035,8 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
-  SetupDrawPropertiesAndUpdateTiles(
-      pending_layer_, 1.1f, device_scale, page_scale, 1.f, false);
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.1f, 1.f, page_scale, 1.f,
+                                    false);
 
   // Our 1.0 tiling now falls outside the range between our ideal scale and our
   // target raster scale. But it is in our used tilings set, so nothing is
@@ -1055,26 +1053,13 @@ TEST_F(PictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
 }
 
-#define EXPECT_BOTH_EQ(expression, x)         \
-  do {                                        \
-    EXPECT_EQ(x, pending_layer_->expression); \
-    EXPECT_EQ(x, active_layer_->expression);  \
-  } while (false)
-
-#define EXPECT_BOTH_NE(expression, x)         \
-  do {                                        \
-    EXPECT_NE(x, pending_layer_->expression); \
-    EXPECT_NE(x, active_layer_->expression);  \
-  } while (false)
-
 TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   // Make sure this layer covers multiple tiles, since otherwise low
   // res won't get created because it is too small.
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
-  SetupDefaultTrees(gfx::Size(tile_size.width() + 1, tile_size.height() + 1));
   // Avoid max untiled layer size heuristics via fixed tile size.
-  pending_layer_->set_fixed_tile_size(tile_size);
-  active_layer_->set_fixed_tile_size(tile_size);
+  gfx::Size layer_bounds(tile_size.width() + 1, tile_size.height() + 1);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   float contents_scale = 1.f;
@@ -1083,6 +1068,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   float maximum_animation_scale = 1.f;
   bool animating_transform = true;
 
+  ResetTilingsAndRasterScales();
+
   // Animating, so don't create low res even if there isn't one already.
   SetContentsScaleOnBothLayers(contents_scale,
                                device_scale,
@@ -1104,7 +1091,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   EXPECT_BOTH_EQ(num_tilings(), 2u);
 
   // Page scale animation, new high res, but no low res. We still have
-  // a tiling at the previous scale, it's just not marked as low res.
+  // a tiling at the previous scale, it's just not marked as low res on the
+  // active layer. The pending layer drops non-ideal tilings.
   contents_scale = 2.f;
   page_scale = 2.f;
   maximum_animation_scale = 2.f;
@@ -1117,7 +1105,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
   EXPECT_FALSE(active_layer_->LowResTiling());
   EXPECT_FALSE(pending_layer_->LowResTiling());
-  EXPECT_BOTH_EQ(num_tilings(), 3u);
+  EXPECT_EQ(3u, active_layer_->num_tilings());
+  EXPECT_EQ(1u, pending_layer_->num_tilings());
 
   // Stop animating, new low res gets created for final page scale.
   animating_transform = false;
@@ -1128,7 +1117,8 @@ TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(), 2.f * low_res_factor);
-  EXPECT_BOTH_EQ(num_tilings(), 4u);
+  EXPECT_EQ(4u, active_layer_->num_tilings());
+  EXPECT_EQ(2u, pending_layer_->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
@@ -1185,120 +1175,187 @@ TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
                  contents_scale * low_res_factor);
   EXPECT_BOTH_EQ(num_tilings(), 2u);
 
-  ResetTilingsAndRasterScales();
-
   // Mask layers dont create low res since they always fit on one tile.
-  pending_layer_->set_is_mask(true);
-  active_layer_->set_is_mask(true);
-  SetContentsScaleOnBothLayers(contents_scale,
-                               device_scale,
-                               page_scale,
-                               maximum_animation_scale,
-                               animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
-  EXPECT_BOTH_EQ(num_tilings(), 1u);
+  scoped_ptr<FakePictureLayerImpl> mask =
+      FakePictureLayerImpl::CreateMaskWithRasterSource(
+          host_impl_.pending_tree(), 3, pending_pile);
+  mask->SetBounds(layer_bounds);
+  mask->SetContentBounds(layer_bounds);
+  mask->SetDrawsContent(true);
+
+  SetupDrawPropertiesAndUpdateTiles(mask.get(), contents_scale, device_scale,
+                                    page_scale, maximum_animation_scale,
+                                    animating_transform);
+  EXPECT_EQ(mask->HighResTiling()->contents_scale(), contents_scale);
+  EXPECT_EQ(mask->num_tilings(), 1u);
 }
 
 TEST_F(PictureLayerImplTest, HugeMasksDontGetTiles) {
+  base::TimeTicks time_ticks;
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+
   gfx::Size tile_size(100, 100);
+  gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(valid_pile);
-  pending_layer_->set_is_mask(true);
 
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
-  EXPECT_EQ(1u, pending_layer_->num_tilings());
+  scoped_ptr<FakePictureLayerImpl> mask_ptr =
+      FakePictureLayerImpl::CreateMaskWithRasterSource(
+          host_impl_.pending_tree(), 3, valid_pile);
+  mask_ptr->SetBounds(layer_bounds);
+  mask_ptr->SetContentBounds(layer_bounds);
+  mask_ptr->SetDrawsContent(true);
+  pending_layer_->SetMaskLayer(mask_ptr.Pass());
+
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  FakePictureLayerImpl* pending_mask =
+      static_cast<FakePictureLayerImpl*>(pending_layer_->mask_layer());
+
+  EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale());
+  EXPECT_EQ(1u, pending_mask->num_tilings());
 
-  pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
-      pending_layer_->HighResTiling()->AllTilesForTesting());
+      pending_mask->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
+  FakePictureLayerImpl* active_mask =
+      static_cast<FakePictureLayerImpl*>(active_layer_->mask_layer());
+
   // Mask layers have a tiling with a single tile in it.
-  EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
+  EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
   ResourceProvider::ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
-  active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_NE(0u, mask_resource_id);
-  EXPECT_EQ(mask_texture_size, active_layer_->bounds());
+  EXPECT_EQ(mask_texture_size, active_mask->bounds());
 
   // Drop resources and recreate them, still the same.
-  old_pending_layer_->ReleaseResources();
-  active_layer_->ReleaseResources();
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  active_layer_->HighResTiling()->CreateAllTilesForTesting();
-  EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
+  pending_mask->ReleaseResources();
+  active_mask->ReleaseResources();
+  SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, false);
+  active_mask->HighResTiling()->CreateAllTilesForTesting();
+  EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   EXPECT_NE(0u, mask_resource_id);
   EXPECT_EQ(mask_texture_size, active_layer_->bounds());
 
+  // Drop resources and recreate them, still the same.
+  pending_mask->ReleaseResources();
+  active_mask->ReleaseResources();
+  SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, false);
+  active_mask->HighResTiling()->CreateAllTilesForTesting();
+  EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
+  EXPECT_NE(0u, mask_resource_id);
+  EXPECT_EQ(mask_texture_size, active_mask->bounds());
+
   // Resize larger than the max texture size.
   int max_texture_size = host_impl_.GetRendererCapabilities().max_texture_size;
+  gfx::Size huge_bounds(max_texture_size + 1, 10);
   scoped_refptr<FakePicturePileImpl> huge_pile =
-      FakePicturePileImpl::CreateFilledPile(
-          tile_size, gfx::Size(max_texture_size + 1, 10));
+      FakePicturePileImpl::CreateFilledPile(tile_size, huge_bounds);
+
   SetupPendingTree(huge_pile);
-  pending_layer_->set_is_mask(true);
+  pending_mask->SetBounds(huge_bounds);
+  pending_mask->SetContentBounds(huge_bounds);
+  pending_mask->SetRasterSourceOnPending(huge_pile, Region());
 
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
-  EXPECT_EQ(1u, pending_layer_->num_tilings());
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale());
+  EXPECT_EQ(1u, pending_mask->num_tilings());
 
-  pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
-      pending_layer_->HighResTiling()->AllTilesForTesting());
+      pending_mask->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   // Mask layers have a tiling, but there should be no tiles in it.
-  EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
+  EXPECT_EQ(0u, active_mask->HighResTiling()->AllTilesForTesting().size());
   // The mask resource is empty.
   active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_EQ(0u, mask_resource_id);
 
   // Drop resources and recreate them, still the same.
-  old_pending_layer_->ReleaseResources();
-  active_layer_->ReleaseResources();
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  active_layer_->HighResTiling()->CreateAllTilesForTesting();
-  EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
+  pending_mask->ReleaseResources();
+  active_mask->ReleaseResources();
+  SetupDrawPropertiesAndUpdateTiles(active_mask, 1.f, 1.f, 1.f, 1.f, false);
+  active_mask->HighResTiling()->CreateAllTilesForTesting();
+  EXPECT_EQ(0u, active_mask->HighResTiling()->AllTilesForTesting().size());
+  active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  EXPECT_EQ(0u, mask_resource_id);
+
+  // Do another activate, the same holds.
+  SetupPendingTree(huge_pile);
+  ActivateTree();
+  EXPECT_EQ(0u, active_mask->HighResTiling()->AllTilesForTesting().size());
   active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_EQ(0u, mask_resource_id);
 }
 
 TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
+  base::TimeTicks time_ticks;
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+
   gfx::Size tile_size(100, 100);
+  gfx::Size layer_bounds(1000, 1000);
+
+  host_impl_.SetDeviceScaleFactor(1.3f);
 
   scoped_refptr<FakePicturePileImpl> valid_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(valid_pile);
-  pending_layer_->set_is_mask(true);
 
-  float ideal_contents_scale = 1.3f;
-  SetupDrawPropertiesAndUpdateTiles(
-      pending_layer_, ideal_contents_scale, 1.f, 1.f, 1.f, false);
-  EXPECT_EQ(ideal_contents_scale,
-            pending_layer_->HighResTiling()->contents_scale());
-  EXPECT_EQ(1u, pending_layer_->num_tilings());
+  scoped_ptr<FakePictureLayerImpl> mask_ptr =
+      FakePictureLayerImpl::CreateMaskWithRasterSource(
+          host_impl_.pending_tree(), 3, valid_pile);
+  mask_ptr->SetBounds(layer_bounds);
+  mask_ptr->SetContentBounds(layer_bounds);
+  mask_ptr->SetDrawsContent(true);
+  pending_layer_->SetMaskLayer(mask_ptr.Pass());
+
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  host_impl_.pending_tree()->UpdateDrawProperties();
+
+  FakePictureLayerImpl* pending_mask =
+      static_cast<FakePictureLayerImpl*>(pending_layer_->mask_layer());
+
+  // Masks are scaled, and do not have a low res tiling.
+  EXPECT_EQ(1.3f, pending_mask->HighResTiling()->contents_scale());
+  EXPECT_EQ(1u, pending_mask->num_tilings());
 
-  pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
-      pending_layer_->HighResTiling()->AllTilesForTesting());
+      pending_mask->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
+  FakePictureLayerImpl* active_mask =
+      static_cast<FakePictureLayerImpl*>(active_layer_->mask_layer());
+
   // Mask layers have a tiling with a single tile in it.
-  EXPECT_EQ(1u, active_layer_->HighResTiling()->AllTilesForTesting().size());
+  EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
   ResourceProvider::ResourceId mask_resource_id;
   gfx::Size mask_texture_size;
-  active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
+  active_mask->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_NE(0u, mask_resource_id);
-  gfx::Size expected_mask_texture_size = gfx::ToCeiledSize(
-      gfx::ScaleSize(active_layer_->bounds(), ideal_contents_scale));
+  gfx::Size expected_mask_texture_size =
+      gfx::ToCeiledSize(gfx::ScaleSize(active_mask->bounds(), 1.3f));
   EXPECT_EQ(mask_texture_size, expected_mask_texture_size);
 }
 
@@ -1312,14 +1369,6 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    1.3f,  // ideal contents scale
-                                    2.7f,  // device scale
-                                    3.2f,  // page scale
-                                    1.f,   // maximum animation scale
-                                    false);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
@@ -1330,10 +1379,10 @@ TEST_F(PictureLayerImplTest, ReleaseResources) {
 
   // This should create new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    1.3f,  // ideal contents scale
-                                    2.7f,  // device scale
-                                    3.2f,  // page scale
-                                    1.f,   // maximum animation scale
+                                    1.f,  // ideal contents scale
+                                    1.f,  // device scale
+                                    1.f,  // page scale
+                                    1.f,  // maximum animation scale
                                     false);
   EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
 }
@@ -1349,10 +1398,7 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
@@ -1364,7 +1410,7 @@ TEST_F(PictureLayerImplTest, ClampTilesToToMaxTileSize) {
   EXPECT_EQ(gfx::Size(256, 256).ToString(),
             tile->content_rect().size().ToString());
 
-  pending_layer_->ReleaseResources();
+  ResetTilingsAndRasterScales();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
@@ -1396,10 +1442,7 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
-  ASSERT_LE(1u, pending_layer_->tilings()->num_tilings());
+  EXPECT_GE(pending_layer_->tilings()->num_tilings(), 1u);
 
   pending_layer_->tilings()->tiling_at(0)->CreateAllTilesForTesting();
 
@@ -1411,7 +1454,7 @@ TEST_F(PictureLayerImplTest, ClampSingleTileToToMaxTileSize) {
   PictureLayerTiling* high_res_tiling = pending_layer_->tilings()->tiling_at(0);
   EXPECT_EQ(1u, high_res_tiling->AllTilesForTesting().size());
 
-  pending_layer_->ReleaseResources();
+  ResetTilingsAndRasterScales();
 
   // Change the max texture size on the output surface context.
   scoped_ptr<TestWebGraphicsContext3D> context =
@@ -1448,15 +1491,12 @@ TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  gfx::Rect layer_invalidation(150, 200, 30, 180);
+  SetupTreesWithInvalidation(pending_pile, active_pile, layer_invalidation);
 
   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, nullptr);
   active_layer_->AppendQuads(render_pass.get(), Occlusion(), &data);
@@ -1514,33 +1554,20 @@ TEST_F(PictureLayerImplTest, TileScalesWithSolidColorPile) {
   pending_pile->set_is_solid_color(false);
   active_pile->set_is_solid_color(true);
   SetupTrees(pending_pile, active_pile);
-  // Solid color layer should not have tilings.
-  ASSERT_FALSE(active_layer_->CanHaveTilings());
-
-  // Update properties with solid color pile should not allow tilings at any
-  // scale.
-  host_impl_.active_tree()->UpdateDrawProperties();
+  // Solid color pile should not allow tilings at any scale.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
   EXPECT_EQ(0.f, active_layer_->ideal_contents_scale());
 
-  // Push non-solid-color pending pile makes active layer can have tilings.
-  active_layer_->UpdateRasterSource(pending_pile);
-  ASSERT_TRUE(active_layer_->CanHaveTilings());
-
-  // Update properties with non-solid color pile should allow tilings.
-  host_impl_.active_tree()->UpdateDrawProperties();
+  // Activate non-solid-color pending pile makes active layer can have tilings.
+  ActivateTree();
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_GT(active_layer_->ideal_contents_scale(), 0.f);
 }
 
-TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
+TEST_F(NoLowResPictureLayerImplTest, 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);
-
   gfx::Transform transform;
   gfx::Transform transform_for_tile_priority;
   bool resourceless_software_draw = false;
@@ -1552,10 +1579,11 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
                                         transform,
                                         resourceless_software_draw);
 
-  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();
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+
+  EXPECT_EQ(1u, pending_layer_->num_tilings());
   EXPECT_EQ(viewport, pending_layer_->visible_rect_for_tile_priority());
 
   base::TimeTicks time_ticks;
@@ -1563,13 +1591,13 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
-  EXPECT_EQ(HIGH_RESOLUTION, tiling->resolution());
 
   int num_visible = 0;
   int num_offscreen = 0;
 
-  for (PictureLayerTiling::TilingRasterTileIterator iter(tiling); iter;
-       ++iter) {
+  for (PictureLayerTiling::TilingRasterTileIterator iter(
+           pending_layer_->HighResTiling());
+       iter; ++iter) {
     const Tile* tile = *iter;
     DCHECK(tile);
     if (tile->priority(PENDING_TREE).distance_to_visible == 0.f) {
@@ -1585,7 +1613,8 @@ TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   EXPECT_GT(num_offscreen, 0);
 }
 
-TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
+TEST_F(NoLowResPictureLayerImplTest,
+       TileOutsideOfViewportForTilePriorityNotRequired) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
   host_impl_.SetCurrentBeginFrameArgs(
@@ -1600,12 +1629,10 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupTrees(pending_pile, active_pile);
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
-  active_layer_->set_fixed_tile_size(tile_size);
-  pending_layer_->set_fixed_tile_size(tile_size);
-  ASSERT_TRUE(pending_layer_->CanHaveTilings());
-  PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
+  ASSERT_EQ(1u, pending_layer_->num_tilings());
+  ASSERT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
 
   // Set external viewport for tile priority.
   gfx::Rect viewport = gfx::Rect(layer_bounds);
@@ -1618,6 +1645,9 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
                                         external_viewport_for_tile_priority,
                                         transform_for_tile_priority,
                                         resourceless_software_draw);
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   // Set visible content rect that is different from
@@ -1637,9 +1667,8 @@ TEST_F(PictureLayerImplTest, TileOutsideOfViewportForTilePriorityNotRequired) {
   int num_inside = 0;
   int num_outside = 0;
   for (PictureLayerTiling::CoverageIterator iter(
-           tiling, pending_layer_->contents_scale_x(), gfx::Rect(layer_bounds));
-       iter;
-       ++iter) {
+           pending_layer_->HighResTiling(), 1.f, gfx::Rect(layer_bounds));
+       iter; ++iter) {
     if (!*iter)
       continue;
     Tile* tile = *iter;
@@ -1683,16 +1712,13 @@ TEST_F(PictureLayerImplTest, HighResTileIsComplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
   ActivateTree();
 
   // All high res tiles have resources.
-  active_layer_->set_fixed_tile_size(tile_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
   std::vector<Tile*> tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
@@ -1719,16 +1745,11 @@ TEST_F(PictureLayerImplTest, HighResTileIsIncomplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
   ActivateTree();
 
-  active_layer_->set_fixed_tile_size(tile_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
-
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
@@ -1750,15 +1771,11 @@ TEST_F(PictureLayerImplTest, HighResTileIsIncompleteLowResComplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
   ActivateTree();
 
-  active_layer_->set_fixed_tile_size(tile_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
   std::vector<Tile*> low_tiles =
       active_layer_->tilings()->tiling_at(1)->AllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(low_tiles);
@@ -1784,16 +1801,12 @@ TEST_F(PictureLayerImplTest, LowResTileIsIncomplete) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
   ActivateTree();
 
   // All high res tiles have resources except one.
-  active_layer_->set_fixed_tile_size(tile_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
   std::vector<Tile*> high_tiles =
       active_layer_->tilings()->tiling_at(0)->AllTilesForTesting();
   high_tiles.erase(high_tiles.begin());
@@ -1826,20 +1839,16 @@ TEST_F(PictureLayerImplTest,
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
+  gfx::Size viewport_size(400, 400);
 
-  host_impl_.SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(viewport_size);
+  host_impl_.SetDeviceScaleFactor(2.f);
 
   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);
-
-  active_layer_->set_fixed_tile_size(tile_size);
-
-  active_layer_->draw_properties().visible_content_rect =
-      gfx::Rect(layer_bounds);
-  SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.f, 1.f, 1.f, 1.f, false);
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
   // One ideal tile exists, this will get used when drawing.
   std::vector<Tile*> ideal_tiles;
@@ -1891,14 +1900,9 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenUnsharedActiveAllReady) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   // No tiles shared.
-  pending_layer_->set_invalidation(gfx::Rect(layer_bounds));
-
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size,
+                                     gfx::Rect(layer_bounds));
 
   active_layer_->SetAllTilesReady();
 
@@ -1915,12 +1919,8 @@ TEST_F(PictureLayerImplTest, HighResRequiredWhenMissingHighResFlagOn) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   // All tiles shared (no invalidation).
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   // Verify active tree not ready.
   Tile* some_active_tile =
@@ -1942,11 +1942,7 @@ TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
@@ -1964,9 +1960,8 @@ TEST_F(PictureLayerImplTest, AllHighResRequiredEvenIfShared) {
 TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
 
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
@@ -1986,6 +1981,7 @@ TEST_F(PictureLayerImplTest, DisallowRequiredForActivation) {
 TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   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
@@ -1995,11 +1991,8 @@ TEST_F(PictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
           tile_size, layer_bounds);
-  SetupTrees(pending_pile, active_pile);
-  pending_layer_->set_fixed_tile_size(tile_size);
-  active_layer_->set_fixed_tile_size(tile_size);
 
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
@@ -2019,17 +2012,11 @@ TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   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);
-  pending_layer_->set_fixed_tile_size(tile_size);
-  active_layer_->set_fixed_tile_size(tile_size);
-
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
   // Active layer can't have tiles.
   EXPECT_FALSE(active_layer_->CanHaveTilings());
@@ -2046,21 +2033,16 @@ TEST_F(PictureLayerImplTest, HighResRequiredIfActiveCantHaveTiles) {
 }
 
 TEST_F(PictureLayerImplTest, HighResRequiredWhenActiveHasDifferentBounds) {
-  gfx::Size layer_bounds(200, 200);
-  gfx::Size tile_size(100, 100);
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   gfx::Size pending_layer_bounds(400, 400);
-  pending_layer_->SetBounds(pending_layer_bounds);
+  gfx::Size active_layer_bounds(200, 200);
+  gfx::Size tile_size(100, 100);
 
-  CreateHighLowResAndSetAllTilesVisible();
-  // TODO(vmpstr): This is confusing. Rework the test to create different bounds
-  // on different trees instead of fudging tilings.
-  pending_layer_->HighResTiling()->ComputeTilePriorityRects(
-      gfx::Rect(pending_layer_bounds), 1.f, 1.f, Occlusion());
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, pending_layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
 
-  pending_layer_->HighResTiling()->UpdateAllTilePrioritiesForTesting();
-  active_layer_->SetAllTilesReady();
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
   // Since the active layer has different bounds, the pending layer needs all
   // high res tiles in order to activate.
@@ -2108,9 +2090,15 @@ TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
 }
 
 TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
-  SetupDefaultTrees(gfx::Size(1500, 1500));
+  gfx::Size layer_bounds(1500, 1500);
+  gfx::Size tile_size(100, 100);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+
+  SetupPendingTree(pending_pile);
 
-  PictureLayerTiling* tiling = pending_layer_->AddTiling(1.f);
+  PictureLayerTiling* tiling = pending_layer_->HighResTiling();
   gfx::Rect first_invalidate = tiling->TilingDataForTesting().TileBounds(0, 0);
   first_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
                          tiling->TilingDataForTesting().border_texels());
@@ -2118,22 +2106,20 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
   second_invalidate.Inset(tiling->TilingDataForTesting().border_texels(),
                           tiling->TilingDataForTesting().border_texels());
 
+  ActivateTree();
+
   // Make a pending tree with an invalidated raster tile 0,0.
-  tiling->CreateAllTilesForTesting();
-  pending_layer_->set_invalidation(first_invalidate);
+  SetupPendingTreeWithInvalidation(pending_pile, first_invalidate);
 
   // Activate and make a pending tree with an invalidated raster tile 1,1.
   ActivateTree();
 
-  host_impl_.CreatePendingTree();
-  pending_layer_ = static_cast<FakePictureLayerImpl*>(
-      host_impl_.pending_tree()->root_layer());
-  pending_layer_->set_invalidation(second_invalidate);
+  SetupPendingTreeWithInvalidation(pending_pile, second_invalidate);
 
   PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
   PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
 
-  pending_tiling->CreateAllTilesForTesting();
+  // pending_tiling->CreateAllTilesForTesting();
 
   // Tile 0,0 should be shared, but tile 1,1 should not be.
   EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
@@ -2162,180 +2148,138 @@ TEST_F(PictureLayerImplTest, ShareTilesOnNextFrame) {
   EXPECT_FALSE(pending_tiling->TileAt(1, 1)->is_shared());
 }
 
-TEST_F(PictureLayerImplTest, ShareTilesOnSync) {
+TEST_F(PictureLayerImplTest, ShareTilesWithNoInvalidation) {
   SetupDefaultTrees(gfx::Size(1500, 1500));
-  AddDefaultTilingsWithInvalidation(gfx::Rect());
 
-  host_impl_.ActivateSyncTree();
-  host_impl_.CreatePendingTree();
-  active_layer_ = static_cast<FakePictureLayerImpl*>(
-      host_impl_.active_tree()->LayerById(id_));
+  EXPECT_GE(active_layer_->num_tilings(), 1u);
+  EXPECT_GE(pending_layer_->num_tilings(), 1u);
 
-  // Force the active tree to sync to the pending tree "post-commit".
-  pending_layer_->DoPostCommitInitializationIfNeeded();
+  // No invalidation, so all tiles are shared.
+  PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
+  PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
+  ASSERT_TRUE(active_tiling);
+  ASSERT_TRUE(pending_tiling);
 
-  // Both invalidations should drop tiles from the pending tree.
-  EXPECT_EQ(3u, active_layer_->num_tilings());
-  EXPECT_EQ(3u, pending_layer_->num_tilings());
-  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
-    PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
-    PictureLayerTiling* pending_tiling =
-        pending_layer_->tilings()->tiling_at(i);
-
-    ASSERT_TRUE(active_tiling);
-    ASSERT_TRUE(pending_tiling);
-
-    EXPECT_TRUE(active_tiling->TileAt(0, 0));
-    EXPECT_TRUE(active_tiling->TileAt(1, 0));
-    EXPECT_TRUE(active_tiling->TileAt(0, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1));
-
-    EXPECT_TRUE(pending_tiling->TileAt(0, 0));
-    EXPECT_TRUE(pending_tiling->TileAt(1, 0));
-    EXPECT_TRUE(pending_tiling->TileAt(0, 1));
-    EXPECT_TRUE(pending_tiling->TileAt(1, 1));
-
-    EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-    EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-    EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
-    EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
-  }
+  EXPECT_TRUE(active_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1));
+
+  EXPECT_TRUE(pending_tiling->TileAt(0, 0));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 0));
+  EXPECT_TRUE(pending_tiling->TileAt(0, 1));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
+
+  EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
 }
 
-TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTilesOnSync) {
-  SetupDefaultTrees(gfx::Size(1500, 1500));
-  AddDefaultTilingsWithInvalidation(gfx::Rect(0, 0, 1, 1));
+TEST_F(PictureLayerImplTest, ShareInvalidActiveTreeTiles) {
+  gfx::Size tile_size(100, 100);
+  gfx::Size layer_bounds(1500, 1500);
 
-  // This activates the 0,0,1,1 invalidation.
-  host_impl_.ActivateSyncTree();
-  host_impl_.CreatePendingTree();
-  active_layer_ = static_cast<FakePictureLayerImpl*>(
-      host_impl_.active_tree()->LayerById(id_));
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupTreesWithInvalidation(pending_pile, active_pile, gfx::Rect(1, 1));
+  // Activate the invalidation.
+  ActivateTree();
+  // Make another pending tree without any invalidation in it.
+  scoped_refptr<FakePicturePileImpl> pending_pile2 =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  SetupPendingTree(pending_pile2);
 
-  // Force the active tree to sync to the pending tree "post-commit".
-  pending_layer_->DoPostCommitInitializationIfNeeded();
+  EXPECT_GE(active_layer_->num_tilings(), 1u);
+  EXPECT_GE(pending_layer_->num_tilings(), 1u);
 
   // The active tree invalidation was handled by the active tiles, so they
   // can be shared with the pending tree.
-  EXPECT_EQ(3u, active_layer_->num_tilings());
-  EXPECT_EQ(3u, pending_layer_->num_tilings());
-  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
-    PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
-    PictureLayerTiling* pending_tiling =
-        pending_layer_->tilings()->tiling_at(i);
-
-    ASSERT_TRUE(active_tiling);
-    ASSERT_TRUE(pending_tiling);
-
-    EXPECT_TRUE(active_tiling->TileAt(0, 0));
-    EXPECT_TRUE(active_tiling->TileAt(1, 0));
-    EXPECT_TRUE(active_tiling->TileAt(0, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1));
-
-    EXPECT_TRUE(pending_tiling->TileAt(0, 0));
-    EXPECT_TRUE(pending_tiling->TileAt(1, 0));
-    EXPECT_TRUE(pending_tiling->TileAt(0, 1));
-    EXPECT_TRUE(pending_tiling->TileAt(1, 1));
-
-    EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-    EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-    EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
-    EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
-  }
-}
+  PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
+  PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
+  ASSERT_TRUE(active_tiling);
+  ASSERT_TRUE(pending_tiling);
 
-TEST_F(PictureLayerImplTest, RemoveInvalidPendingTreeTilesOnSync) {
-  SetupDefaultTrees(gfx::Size(1500, 1500));
-  AddDefaultTilingsWithInvalidation(gfx::Rect());
+  EXPECT_TRUE(active_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1));
 
-  host_impl_.ActivateSyncTree();
-  host_impl_.CreatePendingTree();
-  active_layer_ = static_cast<FakePictureLayerImpl*>(
-      host_impl_.active_tree()->LayerById(id_));
+  EXPECT_TRUE(pending_tiling->TileAt(0, 0));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 0));
+  EXPECT_TRUE(pending_tiling->TileAt(0, 1));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
 
-  // Set some invalidation on the pending tree "during commit". We should
-  // replace raster tiles that touch this.
-  pending_layer_->set_invalidation(gfx::Rect(1, 1));
+  EXPECT_EQ(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 0)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
+}
 
-  // Force the active tree to sync to the pending tree "post-commit".
-  pending_layer_->DoPostCommitInitializationIfNeeded();
+TEST_F(PictureLayerImplTest, RecreateInvalidPendingTreeTiles) {
+  // Set some invalidation on the pending tree. We should replace raster tiles
+  // that touch this.
+  SetupDefaultTreesWithInvalidation(gfx::Size(1500, 1500), gfx::Rect(1, 1));
+
+  EXPECT_GE(active_layer_->num_tilings(), 1u);
+  EXPECT_GE(pending_layer_->num_tilings(), 1u);
 
   // The pending tree invalidation means tiles can not be shared with the
   // active tree.
-  EXPECT_EQ(3u, active_layer_->num_tilings());
-  EXPECT_EQ(3u, pending_layer_->num_tilings());
-  for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
-    PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(i);
-    PictureLayerTiling* pending_tiling =
-        pending_layer_->tilings()->tiling_at(i);
-
-    ASSERT_TRUE(active_tiling);
-    ASSERT_TRUE(pending_tiling);
-
-    EXPECT_TRUE(active_tiling->TileAt(0, 0));
-    EXPECT_TRUE(active_tiling->TileAt(1, 0));
-    EXPECT_TRUE(active_tiling->TileAt(0, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1));
-
-    EXPECT_TRUE(pending_tiling->TileAt(0, 0));
-    EXPECT_TRUE(pending_tiling->TileAt(1, 0));
-    EXPECT_TRUE(pending_tiling->TileAt(0, 1));
-    EXPECT_TRUE(pending_tiling->TileAt(1, 1));
-
-    EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
-    EXPECT_FALSE(active_tiling->TileAt(0, 0)->is_shared());
-    EXPECT_FALSE(pending_tiling->TileAt(0, 0)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
-    EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
-    EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
-    EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
-  }
+  PictureLayerTiling* active_tiling = active_layer_->tilings()->tiling_at(0);
+  PictureLayerTiling* pending_tiling = pending_layer_->tilings()->tiling_at(0);
+  ASSERT_TRUE(active_tiling);
+  ASSERT_TRUE(pending_tiling);
+
+  EXPECT_TRUE(active_tiling->TileAt(0, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(0, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1));
+
+  EXPECT_TRUE(pending_tiling->TileAt(0, 0));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 0));
+  EXPECT_TRUE(pending_tiling->TileAt(0, 1));
+  EXPECT_TRUE(pending_tiling->TileAt(1, 1));
+
+  EXPECT_NE(active_tiling->TileAt(0, 0), pending_tiling->TileAt(0, 0));
+  EXPECT_FALSE(active_tiling->TileAt(0, 0)->is_shared());
+  EXPECT_FALSE(pending_tiling->TileAt(0, 0)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(1, 0), pending_tiling->TileAt(1, 0));
+  EXPECT_TRUE(active_tiling->TileAt(1, 0)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(0, 1), pending_tiling->TileAt(0, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
+  EXPECT_EQ(active_tiling->TileAt(1, 1), pending_tiling->TileAt(1, 1));
+  EXPECT_TRUE(active_tiling->TileAt(1, 1)->is_shared());
 }
 
-TEST_F(PictureLayerImplTest, SyncTilingAfterReleaseResource) {
-  SetupDefaultTrees(gfx::Size(10, 10));
-  host_impl_.active_tree()->UpdateDrawProperties();
-  EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
+TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
+  base::TimeTicks time_ticks;
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
 
-  // Contrived unit test of a real crash. A layer is transparent during a
-  // context loss, and later becomes opaque, causing active layer SyncTiling to
-  // be called.
-  float new_scale = 1.f;
-  active_layer_->ReleaseResources();
-  pending_layer_->ReleaseResources();
-  EXPECT_FALSE(active_layer_->tilings()->FindTilingWithScale(new_scale));
-  pending_layer_->AddTiling(new_scale);
-  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(new_scale));
-
-  // UpdateDrawProperties early-outs if the tree doesn't need it.  It is also
-  // responsible for calling ManageTilings.  These checks verify that
-  // ReleaseResources has set needs update draw properties so that the
-  // new tiling gets the appropriate resolution set in ManageTilings.
-  EXPECT_TRUE(host_impl_.active_tree()->needs_update_draw_properties());
-  host_impl_.active_tree()->UpdateDrawProperties();
-  PictureLayerTiling* high_res =
-      active_layer_->tilings()->FindTilingWithScale(new_scale);
-  ASSERT_TRUE(!!high_res);
-  EXPECT_EQ(HIGH_RESOLUTION, high_res->resolution());
-}
+  gfx::Size tile_size(100, 100);
+  gfx::Size layer_bounds(10, 10);
 
-TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
-  SetupDefaultTrees(gfx::Size(10, 10));
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  const float kScale = 1.f;
-  pending_layer_->AddTiling(kScale);
-  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(kScale));
-  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(kScale));
+  SetupTrees(pending_pile, active_pile);
+
+  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
+  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(1.f));
 
   // Gpu rasterization is disabled by default.
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
@@ -2346,9 +2290,17 @@ TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
 
   // Make sure that we can still add tiling to the pending layer,
   // that gets synced to the active layer.
-  pending_layer_->AddTiling(kScale);
-  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(kScale));
-  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(kScale));
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  host_impl_.pending_tree()->UpdateDrawProperties();
+  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
+
+  ActivateTree();
+  EXPECT_TRUE(active_layer_->tilings()->FindTilingWithScale(1.f));
+
+  SetupPendingTree(pending_pile);
+  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.f));
 
   // Toggling the gpu rasterization clears all tilings on both trees.
   EXPECT_TRUE(host_impl_.use_gpu_rasterization());
@@ -2360,72 +2312,62 @@ TEST_F(PictureLayerImplTest, SyncTilingAfterGpuRasterizationToggles) {
 TEST_F(PictureLayerImplTest, HighResCreatedWhenBoundsShrink) {
   gfx::Size tile_size(100, 100);
 
-  scoped_refptr<FakePicturePileImpl> active_pile =
-      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(10, 10));
-  SetupPendingTree(active_pile);
-  ActivateTree();
-  host_impl_.active_tree()->UpdateDrawProperties();
-  EXPECT_FALSE(host_impl_.active_tree()->needs_update_draw_properties());
+  // Put 0.5 as high res.
+  host_impl_.SetDeviceScaleFactor(0.5f);
 
-  SetupDrawPropertiesAndUpdateTiles(
-      active_layer_, 0.5f, 0.5f, 0.5f, 0.5f, false);
-  active_layer_->tilings()->RemoveAllTilings();
-  PictureLayerTiling* tiling = active_layer_->AddTiling(0.5f);
-  active_layer_->AddTiling(1.5f);
-  active_layer_->AddTiling(0.25f);
-  tiling->set_resolution(HIGH_RESOLUTION);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(10, 10));
+  SetupPendingTree(pending_pile);
 
   // Sanity checks.
-  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
-  ASSERT_EQ(tiling, active_layer_->tilings()->FindTilingWithScale(0.5f));
+  EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
+  EXPECT_TRUE(pending_layer_->tilings()->FindTilingWithScale(0.5f));
 
-  // Now, set the bounds to be 1x1 (so that minimum contents scale becomes
-  // 1.0f). Note that we should also ensure that the pending layer needs post
-  // commit initialization, since this is what would happen during commit. In
-  // other words we want the pending layer to sync from the active layer.
-  scoped_refptr<FakePicturePileImpl> pending_pile =
+  ActivateTree();
+
+  // Now, set the bounds to be 1x1, so that minimum contents scale becomes 1.
+  pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1, 1));
   SetupPendingTree(pending_pile);
 
-  // Update the draw properties: sync from active tree should happen here.
-  host_impl_.pending_tree()->UpdateDrawProperties();
-  EXPECT_FALSE(pending_layer_->needs_post_commit_initialization());
-
   // Another sanity check.
-  ASSERT_EQ(1.f, pending_layer_->MinimumContentsScale());
+  EXPECT_EQ(1.f, pending_layer_->MinimumContentsScale());
 
-  // Now we should've synced 1.5f tiling, since that's the only one that doesn't
-  // violate minimum contents scale. At the same time, we should've created a
-  // new high res tiling at scale 1.0f.
-  EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
-  ASSERT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.0f));
-  EXPECT_EQ(HIGH_RESOLUTION,
-            pending_layer_->tilings()->FindTilingWithScale(1.0f)->resolution());
-  ASSERT_TRUE(pending_layer_->tilings()->FindTilingWithScale(1.5f));
-  EXPECT_EQ(NON_IDEAL_RESOLUTION,
-            pending_layer_->tilings()->FindTilingWithScale(1.5f)->resolution());
+  // Since the MinContentsScale is 1, the 0.5 tiling should be replaced by a 1.0
+  // tiling.
+  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 0.5f, 1.f, 1.f, 1.f, false);
+
+  EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
+  PictureLayerTiling* tiling =
+      pending_layer_->tilings()->FindTilingWithScale(1.0f);
+  ASSERT_TRUE(tiling);
+  EXPECT_EQ(HIGH_RESOLUTION, tiling->resolution());
 }
 
-TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
+TEST_F(PictureLayerImplTest, LowResTilingWithoutGpuRasterization) {
   gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
   gfx::Size layer_bounds(default_tile_size.width() * 4,
                          default_tile_size.height() * 4);
 
+  host_impl_.SetUseGpuRasterization(false);
+
   SetupDefaultTrees(layer_bounds);
   EXPECT_FALSE(host_impl_.use_gpu_rasterization());
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
   // Should have a low-res and a high-res tiling.
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(2u, pending_layer_->tilings()->num_tilings());
+}
 
-  ResetTilingsAndRasterScales();
+TEST_F(PictureLayerImplTest, NoLowResTilingWithGpuRasterization) {
+  gfx::Size default_tile_size(host_impl_.settings().default_tile_size);
+  gfx::Size layer_bounds(default_tile_size.width() * 4,
+                         default_tile_size.height() * 4);
 
   host_impl_.SetUseGpuRasterization(true);
-  EXPECT_TRUE(host_impl_.use_gpu_rasterization());
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
+  SetupDefaultTrees(layer_bounds);
+  EXPECT_TRUE(host_impl_.use_gpu_rasterization());
   // Should only have the high-res tiling.
-  ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
@@ -2450,31 +2392,38 @@ TEST_F(PictureLayerImplTest, NoTilingIfDoesNotDrawContent) {
 
 TEST_F(PictureLayerImplTest, FirstTilingDuringPinch) {
   SetupDefaultTrees(gfx::Size(10, 10));
+
+  // We start with a tiling at scale 1.
+  EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
+
+  // When we scale up by 2.3, we get a new tiling that is a power of 2, in this
+  // case 4.
   host_impl_.PinchGestureBegin();
   float high_res_scale = 2.3f;
   SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
-
-  ASSERT_GE(pending_layer_->num_tilings(), 0u);
-  EXPECT_FLOAT_EQ(high_res_scale,
-                  pending_layer_->HighResTiling()->contents_scale());
+  EXPECT_EQ(4.f, pending_layer_->HighResTiling()->contents_scale());
 }
 
-TEST_F(PictureLayerImplTest, FirstTilingTooSmall) {
+TEST_F(PictureLayerImplTest, PinchingTooSmall) {
   SetupDefaultTrees(gfx::Size(10, 10));
+
+  // We start with a tiling at scale 1.
+  EXPECT_EQ(1.f, pending_layer_->HighResTiling()->contents_scale());
+
   host_impl_.PinchGestureBegin();
   float high_res_scale = 0.0001f;
-  EXPECT_GT(pending_layer_->MinimumContentsScale(), high_res_scale);
+  EXPECT_LT(high_res_scale, pending_layer_->MinimumContentsScale());
 
-  SetContentsScaleOnBothLayers(high_res_scale, 1.f, 1.f, 1.f, false);
-
-  ASSERT_GE(pending_layer_->num_tilings(), 0u);
+  SetContentsScaleOnBothLayers(high_res_scale, 1.f, high_res_scale, 1.f, false);
   EXPECT_FLOAT_EQ(pending_layer_->MinimumContentsScale(),
                   pending_layer_->HighResTiling()->contents_scale());
 }
 
-TEST_F(PictureLayerImplTest, PinchingTooSmall) {
+TEST_F(PictureLayerImplTest, PinchingTooSmallWithContentsScale) {
   SetupDefaultTrees(gfx::Size(10, 10));
 
+  ResetTilingsAndRasterScales();
+
   float contents_scale = 0.15f;
   SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, 1.f, false);
 
@@ -2542,22 +2491,18 @@ TEST_F(DeferredInitPictureLayerImplTest, PreventUpdateTilesDuringLostContext) {
 }
 
 TEST_F(PictureLayerImplTest, HighResTilingDuringAnimationForCpuRasterization) {
-  gfx::Size layer_bounds(100, 100);
   gfx::Size viewport_size(1000, 1000);
-  SetupDefaultTrees(layer_bounds);
   host_impl_.SetViewportSize(viewport_size);
 
+  gfx::Size layer_bounds(100, 100);
+  SetupDefaultTrees(layer_bounds);
+
   float contents_scale = 1.f;
-  float device_scale = 1.3f;
-  float page_scale = 1.4f;
+  float device_scale = 1.f;
+  float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   bool animating_transform = false;
 
-  SetContentsScaleOnBothLayers(contents_scale,
-                               device_scale,
-                               page_scale,
-                               maximum_animation_scale,
-                               animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
 
   // Since we're CPU-rasterizing, starting an animation should cause tiling
@@ -2781,6 +2726,8 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
   host_impl_.SetCurrentBeginFrameArgs(
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
 
+  host_impl_.SetViewportSize(gfx::Size(500, 500));
+
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
@@ -2788,24 +2735,10 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupPendingTree(pending_pile);
+  EXPECT_EQ(2u, pending_layer_->num_tilings());
 
-  ASSERT_TRUE(pending_layer_->CanHaveTilings());
-
-  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
-
-  // No tilings.
   scoped_ptr<TilingSetRasterQueue> queue =
       pending_layer_->CreateRasterQueue(false);
-  EXPECT_TRUE(queue->IsEmpty());
-
-  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);
-
-  host_impl_.SetViewportSize(gfx::Size(500, 500));
-  host_impl_.pending_tree()->UpdateDrawProperties();
 
   std::set<Tile*> unique_tiles;
   bool reached_prepaint = false;
@@ -2883,7 +2816,8 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
       gfx::Rect(0, 0, 500, 500);
   pending_layer_->UpdateTiles(Occlusion(), resourceless_software_draw);
 
-  std::vector<Tile*> high_res_tiles = high_res_tiling->AllTilesForTesting();
+  std::vector<Tile*> high_res_tiles =
+      pending_layer_->HighResTiling()->AllTilesForTesting();
   for (std::vector<Tile*>::iterator tile_it = high_res_tiles.begin();
        tile_it != high_res_tiles.end();
        ++tile_it) {
@@ -2916,33 +2850,23 @@ TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
 TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
+  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+
+  host_impl_.SetViewportSize(gfx::Size(500, 500));
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
+  // TODO(vmpstr): Add a test with tilings other than high/low res on the active
+  // tree.
   SetupPendingTree(pending_pile);
-
-  ASSERT_TRUE(pending_layer_->CanHaveTilings());
-
-  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
-
-  std::vector<PictureLayerTiling*> tilings;
-  tilings.push_back(pending_layer_->AddTiling(low_res_factor));
-  tilings.push_back(pending_layer_->AddTiling(0.3f));
-  tilings.push_back(pending_layer_->AddTiling(0.7f));
-  tilings.push_back(pending_layer_->AddTiling(1.0f));
-  tilings.push_back(pending_layer_->AddTiling(2.0f));
-
-  host_impl_.SetViewportSize(gfx::Size(500, 500));
-  host_impl_.pending_tree()->UpdateDrawProperties();
+  EXPECT_EQ(2u, pending_layer_->num_tilings());
 
   std::vector<Tile*> all_tiles;
-  for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
-           tilings.begin();
-       tiling_iterator != tilings.end();
-       ++tiling_iterator) {
-    std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
-    std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+    all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
   }
 
   std::set<Tile*> all_tiles_set(all_tiles.begin(), all_tiles.end());
@@ -2950,8 +2874,8 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
   bool mark_required = false;
   size_t number_of_marked_tiles = 0u;
   size_t number_of_unmarked_tiles = 0u;
-  for (size_t i = 0; i < tilings.size(); ++i) {
-    PictureLayerTiling* tiling = tilings.at(i);
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              pending_layer_->contents_scale_x(),
@@ -2969,8 +2893,8 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
   }
 
   // Sanity checks.
-  EXPECT_EQ(91u, all_tiles.size());
-  EXPECT_EQ(91u, all_tiles_set.size());
+  EXPECT_EQ(17u, all_tiles.size());
+  EXPECT_EQ(17u, all_tiles_set.size());
   EXPECT_GT(number_of_marked_tiles, 1u);
   EXPECT_GT(number_of_unmarked_tiles, 1u);
 
@@ -2982,7 +2906,7 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
 
   std::set<Tile*> unique_tiles;
-  float expected_scales[] = {2.0f, 0.3f, 0.7f, low_res_factor, 1.0f};
+  float expected_scales[] = {low_res_factor, 1.f};
   size_t scale_index = 0;
   bool reached_visible = false;
   Tile* last_tile = nullptr;
@@ -3029,8 +2953,9 @@ TEST_F(PictureLayerImplTest, TilingSetEvictionQueue) {
     queue->Pop();
   }
 
+  // 4 high res tiles are inside the viewport, the rest are evicted.
   EXPECT_TRUE(reached_visible);
-  EXPECT_EQ(65u, unique_tiles.size());
+  EXPECT_EQ(12u, unique_tiles.size());
 
   scale_index = 0;
   bool reached_required = false;
@@ -3069,16 +2994,12 @@ TEST_F(PictureLayerImplTest, Occlusion) {
   gfx::Size viewport_size(1000, 1000);
 
   LayerTestCommon::LayerImplTest impl;
+  host_impl_.SetViewportSize(viewport_size);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(layer_bounds, layer_bounds);
-  SetupPendingTree(pending_pile);
-  pending_layer_->SetBounds(layer_bounds);
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
   ActivateTree();
-  active_layer_->set_fixed_tile_size(tile_size);
-
-  host_impl_.SetViewportSize(viewport_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
 
   std::vector<Tile*> tiles =
       active_layer_->HighResTiling()->AllTilesForTesting();
@@ -3121,6 +3042,8 @@ TEST_F(PictureLayerImplTest, RasterScaleChangeWithoutAnimation) {
   gfx::Size tile_size(host_impl_.settings().default_tile_size);
   SetupDefaultTrees(tile_size);
 
+  ResetTilingsAndRasterScales();
+
   float contents_scale = 2.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
@@ -3161,15 +3084,9 @@ TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   // Make sure some tiles are not shared.
-  pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
-
-  CreateHighLowResAndSetAllTilesVisible();
-  active_layer_->SetAllTilesReady();
+  gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // All pending layer tiles required are not ready.
   EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
@@ -3190,15 +3107,9 @@ TEST_F(PictureLayerImplTest, HighResReadyToDrawEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   // Make sure some tiles are not shared.
-  pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
-
-  CreateHighLowResAndSetAllTilesVisible();
-  active_layer_->SetAllTilesReady();
+  gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // All pending layer tiles required are not ready.
   EXPECT_FALSE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
@@ -3215,14 +3126,9 @@ TEST_F(PictureLayerImplTest,
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   // Make sure some tiles are not shared.
-  pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
-
-  CreateHighLowResAndSetAllTilesVisible();
+  gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // Initialize all high-res tiles in the active layer.
   active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
@@ -3241,14 +3147,9 @@ TEST_F(PictureLayerImplTest, SharedActiveHighResReadyNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
   // Make sure some tiles are not shared.
-  pending_layer_->set_invalidation(gfx::Rect(gfx::Point(50, 50), tile_size));
-
-  CreateHighLowResAndSetAllTilesVisible();
+  gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
   // Initialize all high-res tiles in the active layer.
   active_layer_->SetAllTilesReadyInTiling(active_layer_->HighResTiling());
@@ -3261,12 +3162,6 @@ TEST_F(PictureLayerImplTest, SharedActiveHighResReadyNotEnoughToActivate) {
   EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
 }
 
-class NoLowResPictureLayerImplTest : public PictureLayerImplTest {
- public:
-  NoLowResPictureLayerImplTest()
-      : PictureLayerImplTest(NoLowResTilingsSettings()) {}
-};
-
 TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
@@ -3277,11 +3172,73 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  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);
 
+  ResetTilingsAndRasterScales();
+
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    6.f,  // ideal contents scale
+                                    3.f,  // device scale
+                                    2.f,  // page scale
+                                    1.f,  // maximum animation scale
+                                    false);
+  ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(6.f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+
+  // If we change the page scale factor, then we should get new tilings.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    6.6f,  // ideal contents scale
+                                    3.f,   // device scale
+                                    2.2f,  // page scale
+                                    1.f,   // maximum animation scale
+                                    false);
+  ASSERT_EQ(2u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(6.6f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+
+  // If we change the device scale factor, then we should get new tilings.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    7.26f,  // ideal contents scale
+                                    3.3f,   // device scale
+                                    2.2f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
+  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(7.26f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+
+  // If we change the device scale factor, but end up at the same total scale
+  // factor somehow, then we don't get new tilings.
+  SetupDrawPropertiesAndUpdateTiles(active_layer_,
+                                    7.26f,  // ideal contents scale
+                                    2.2f,   // device scale
+                                    3.3f,   // page scale
+                                    1.f,    // maximum animation scale
+                                    false);
+  ASSERT_EQ(3u, active_layer_->tilings()->num_tilings());
+  EXPECT_FLOAT_EQ(7.26f,
+                  active_layer_->tilings()->tiling_at(0)->contents_scale());
+}
+
+TEST_F(NoLowResPictureLayerImplTest, PendingLayerOnlyHasHighResTiling) {
+  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);
+
+  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+  EXPECT_LT(low_res_factor, 1.f);
+
+  ResetTilingsAndRasterScales();
+
   SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
@@ -3299,7 +3256,7 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
                                     2.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     false);
-  ASSERT_EQ(2u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(6.6f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
@@ -3310,7 +3267,7 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
                                     2.2f,   // page scale
                                     1.f,    // maximum animation scale
                                     false);
-  ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 
@@ -3322,7 +3279,7 @@ TEST_F(NoLowResPictureLayerImplTest, ManageTilingsCreatesTilings) {
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     false);
-  ASSERT_EQ(3u, pending_layer_->tilings()->num_tilings());
+  ASSERT_EQ(1u, pending_layer_->tilings()->num_tilings());
   EXPECT_FLOAT_EQ(7.26f,
                   pending_layer_->tilings()->tiling_at(0)->contents_scale());
 }
@@ -3331,11 +3288,7 @@ TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
-  host_impl_.SetViewportSize(layer_bounds);
-
-  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size);
-
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer_->HighResTiling()->AllTilesForTesting()[0];
@@ -3355,6 +3308,7 @@ TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfShared) {
 TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   gfx::Size layer_bounds(400, 400);
   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
@@ -3364,11 +3318,8 @@ TEST_F(NoLowResPictureLayerImplTest, NothingRequiredIfActiveMissingTiles) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
           tile_size, layer_bounds);
-  SetupTrees(pending_pile, active_pile);
-  pending_layer_->set_fixed_tile_size(tile_size);
-  active_layer_->set_fixed_tile_size(tile_size);
 
-  CreateHighLowResAndSetAllTilesVisible();
+  SetupTreesWithFixedTileSize(pending_pile, active_pile, tile_size, Region());
 
   // Active layer has tilings, but no tiles due to missing recordings.
   EXPECT_TRUE(active_layer_->CanHaveTilings());
@@ -3401,10 +3352,8 @@ TEST_F(NoLowResPictureLayerImplTest, InvalidViewportForPrioritizingTiles) {
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SetupTrees(pending_pile, active_pile);
+  SetupTreesWithInvalidation(pending_pile, active_pile, Region());
 
-  Region invalidation;
-  AddDefaultTilingsWithInvalidation(invalidation);
   SetupDrawPropertiesAndUpdateTiles(active_layer_, 1.f, 1.f, 1.f, 1.f, false);
 
   // UpdateTiles with valid viewport. Should update tile viewport.
@@ -3484,7 +3433,6 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   std::vector<PictureLayerTiling*> used_tilings;
 
   SetupTrees(pending_pile, active_pile);
-  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);
@@ -3493,6 +3441,8 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   float page_scale = 3.2f;
   float scale = 1.f;
 
+  ResetTilingsAndRasterScales();
+
   SetContentsScaleOnBothLayers(scale, device_scale, page_scale, 1.f, false);
   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
 
@@ -3578,80 +3528,6 @@ TEST_F(NoLowResPictureLayerImplTest, CleanUpTilings) {
   ASSERT_EQ(1u, active_layer_->tilings()->num_tilings());
 }
 
-TEST_F(PictureLayerImplTest, ScaleCollision) {
-  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);
-
-  std::vector<PictureLayerTiling*> used_tilings;
-
-  SetupTrees(pending_pile, active_pile);
-
-  float pending_contents_scale = 1.f;
-  float active_contents_scale = 2.f;
-  float device_scale_factor = 1.f;
-  float page_scale_factor = 1.f;
-  float maximum_animation_contents_scale = 1.f;
-  bool animating_transform = false;
-
-  EXPECT_TRUE(host_impl_.settings().create_low_res_tiling);
-  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
-  EXPECT_LT(low_res_factor, 1.f);
-
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    pending_contents_scale,
-                                    device_scale_factor,
-                                    page_scale_factor,
-                                    maximum_animation_contents_scale,
-                                    animating_transform);
-  SetupDrawPropertiesAndUpdateTiles(active_layer_,
-                                    active_contents_scale,
-                                    device_scale_factor,
-                                    page_scale_factor,
-                                    maximum_animation_contents_scale,
-                                    animating_transform);
-
-  ASSERT_EQ(4u, pending_layer_->tilings()->num_tilings());
-  ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
-
-  EXPECT_EQ(active_contents_scale,
-            pending_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_EQ(pending_contents_scale,
-            pending_layer_->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_EQ(active_contents_scale * low_res_factor,
-            pending_layer_->tilings()->tiling_at(2)->contents_scale());
-  EXPECT_EQ(pending_contents_scale * low_res_factor,
-            pending_layer_->tilings()->tiling_at(3)->contents_scale());
-
-  EXPECT_EQ(active_contents_scale,
-            active_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_EQ(pending_contents_scale,
-            active_layer_->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_EQ(active_contents_scale * low_res_factor,
-            active_layer_->tilings()->tiling_at(2)->contents_scale());
-  EXPECT_EQ(pending_contents_scale * low_res_factor,
-            active_layer_->tilings()->tiling_at(3)->contents_scale());
-
-  // The unused low res tiling from the pending tree must be kept or we may add
-  // it again on the active tree and collide with the pending tree.
-  used_tilings.push_back(active_layer_->tilings()->tiling_at(1));
-  active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
-  ASSERT_EQ(4u, active_layer_->tilings()->num_tilings());
-
-  EXPECT_EQ(active_contents_scale,
-            active_layer_->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_EQ(pending_contents_scale,
-            active_layer_->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_EQ(active_contents_scale * low_res_factor,
-            active_layer_->tilings()->tiling_at(2)->contents_scale());
-  EXPECT_EQ(pending_contents_scale * low_res_factor,
-            active_layer_->tilings()->tiling_at(3)->contents_scale());
-}
-
 TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
@@ -3662,15 +3538,8 @@ TEST_F(NoLowResPictureLayerImplTest, ReleaseResources) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
-  EXPECT_EQ(0u, pending_layer_->tilings()->num_tilings());
-
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_,
-                                    1.3f,  // ideal contents scale
-                                    2.7f,  // device scale
-                                    3.2f,  // page scale
-                                    1.f,   // maximum animation scale
-                                    false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
+  EXPECT_EQ(1u, active_layer_->tilings()->num_tilings());
 
   // All tilings should be removed when losing output surface.
   active_layer_->ReleaseResources();
@@ -3694,7 +3563,7 @@ TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1000, 2000);
 
-  host_impl_.SetViewportSize(layer_bounds);
+  host_impl_.SetViewportSize(gfx::Size(10000, 20000));
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
@@ -3703,14 +3572,12 @@ TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
 
   SetupTrees(pending_pile, active_pile);
 
-  SetupDrawPropertiesAndUpdateTiles(pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
-  host_impl_.pending_tree()->UpdateDrawProperties();
-
-  active_layer_->draw_properties().visible_content_rect =
-      gfx::Rect(layer_bounds);
-  host_impl_.active_tree()->UpdateDrawProperties();
+  ResetTilingsAndRasterScales();
+  SetupDrawPropertiesAndUpdateTiles(active_layer_, 2.5f, 1.f, 1.f, 1.f, false);
 
   float max_contents_scale = active_layer_->MaximumTilingContentsScale();
+  EXPECT_EQ(2.5f, max_contents_scale);
+
   gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
@@ -3747,40 +3614,35 @@ TEST_F(PictureLayerImplTest, UpdateTilesForMasksWithNoVisibleContent) {
 
   scoped_ptr<FakePictureLayerImpl> layer_with_mask =
       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 2);
-
   layer_with_mask->SetBounds(bounds);
   layer_with_mask->SetContentBounds(bounds);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, bounds);
   scoped_ptr<FakePictureLayerImpl> mask =
-      FakePictureLayerImpl::CreateWithRasterSource(host_impl_.pending_tree(), 3,
-                                                   pending_pile);
-  mask->set_is_mask(true);
-
+      FakePictureLayerImpl::CreateMaskWithRasterSource(
+          host_impl_.pending_tree(), 3, pending_pile);
   mask->SetBounds(bounds);
   mask->SetContentBounds(bounds);
   mask->SetDrawsContent(true);
-
-  FakePictureLayerImpl* pending_mask_content = mask.get();
   layer_with_mask->SetMaskLayer(mask.Pass());
 
+  FakePictureLayerImpl* pending_mask =
+      static_cast<FakePictureLayerImpl*>(layer_with_mask->mask_layer());
+
   scoped_ptr<FakePictureLayerImpl> child_of_layer_with_mask =
       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 4);
-
   child_of_layer_with_mask->SetBounds(bounds);
   child_of_layer_with_mask->SetContentBounds(bounds);
   child_of_layer_with_mask->SetDrawsContent(true);
-
   layer_with_mask->AddChild(child_of_layer_with_mask.Pass());
-
   root->AddChild(layer_with_mask.Pass());
 
   host_impl_.pending_tree()->SetRootLayer(root.Pass());
 
-  EXPECT_FALSE(pending_mask_content->tilings());
+  EXPECT_EQ(0u, pending_mask->num_tilings());
   host_impl_.pending_tree()->UpdateDrawProperties();
-  EXPECT_NE(0u, pending_mask_content->num_tilings());
+  EXPECT_NE(0u, pending_mask->num_tilings());
 }
 
 class PictureLayerImplTestWithDelegatingRenderer : public PictureLayerImplTest {
@@ -3804,7 +3666,6 @@ TEST_F(PictureLayerImplTestWithDelegatingRenderer,
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   SetupPendingTree(pending_pile);
   pending_layer_->SetBounds(layer_bounds);
-  host_impl_.SetViewportSize(layer_bounds);
   ActivateTree();
   host_impl_.active_tree()->UpdateDrawProperties();
   std::vector<Tile*> tiles =
@@ -3911,13 +3772,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   gfx::Size viewport_size(500, 500);
   gfx::Point occluding_layer_position(310, 0);
 
+  host_impl_.SetViewportSize(viewport_size);
+
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
-  pending_layer_->set_fixed_tile_size(tile_size);
-
-  host_impl_.SetViewportSize(viewport_size);
-  host_impl_.pending_tree()->UpdateDrawProperties();
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
 
   // No occlusion.
   int unoccluded_tile_count = 0;
@@ -4004,13 +3863,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   gfx::Size viewport_size(500, 500);
   gfx::Point occluding_layer_position(310, 0);
 
+  host_impl_.SetViewportSize(viewport_size);
+
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
-  pending_layer_->set_fixed_tile_size(tile_size);
-
-  host_impl_.SetViewportSize(viewport_size);
-  host_impl_.pending_tree()->UpdateDrawProperties();
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
 
   // No occlusion.
   int occluded_tile_count = 0;
@@ -4125,6 +3982,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
+  base::TimeTicks time_ticks;
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
   gfx::Size viewport_size(500, 500);
@@ -4132,19 +3994,11 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupPendingTree(pending_pile);
-  pending_layer_->set_fixed_tile_size(tile_size);
 
-  ASSERT_TRUE(pending_layer_->CanHaveTilings());
-
-  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+  host_impl_.SetViewportSize(viewport_size);
 
-  std::vector<PictureLayerTiling*> tilings;
-  tilings.push_back(pending_layer_->AddTiling(low_res_factor));
-  tilings.push_back(pending_layer_->AddTiling(0.3f));
-  tilings.push_back(pending_layer_->AddTiling(0.7f));
-  tilings.push_back(pending_layer_->AddTiling(1.0f));
-  tilings.push_back(pending_layer_->AddTiling(2.0f));
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, Region());
+  ASSERT_TRUE(pending_layer_->CanHaveTilings());
 
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
   LayerImpl* layer1 = pending_layer_->children()[0];
@@ -4154,49 +4008,56 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
-  host_impl_.SetViewportSize(viewport_size);
+  pending_layer_->tilings()->RemoveAllTilings();
+  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);
+  pending_layer_->AddTiling(1.0f);
+  pending_layer_->AddTiling(2.0f);
+
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  // UpdateDrawProperties with the occluding layer.
   host_impl_.pending_tree()->UpdateDrawProperties();
 
-  int tiling_count = 0;
+  EXPECT_EQ(5u, pending_layer_->num_tilings());
+
   int occluded_tile_count = 0;
-  for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
-           tilings.begin();
-       tiling_iterator != tilings.end();
-       ++tiling_iterator) {
-    (*tiling_iterator)->UpdateAllTilePrioritiesForTesting();
-    std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+    tiling->UpdateAllTilePrioritiesForTesting();
+    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 
     occluded_tile_count = 0;
-    for (size_t i = 0; i < tiles.size(); ++i) {
-      if (tiles[i]->is_occluded(PENDING_TREE)) {
+    for (size_t j = 0; j < tiles.size(); ++j) {
+      if (tiles[j]->is_occluded(PENDING_TREE)) {
         gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
-            tiles[i]->content_rect(), 1.0f / tiles[i]->contents_scale());
+            tiles[j]->content_rect(), 1.0f / tiles[j]->contents_scale());
         EXPECT_GE(scaled_content_rect.x(), occluding_layer_position.x());
         occluded_tile_count++;
       }
     }
-    switch (tiling_count) {
+
+    switch (i) {
       case 0:
+        EXPECT_EQ(occluded_tile_count, 30);
+        break;
       case 1:
-        EXPECT_EQ(occluded_tile_count, 2);
+        EXPECT_EQ(occluded_tile_count, 5);
         break;
       case 2:
         EXPECT_EQ(occluded_tile_count, 4);
         break;
-      case 3:
-        EXPECT_EQ(occluded_tile_count, 5);
-        break;
       case 4:
-        EXPECT_EQ(occluded_tile_count, 30);
+      case 3:
+        EXPECT_EQ(occluded_tile_count, 2);
         break;
       default:
         NOTREACHED();
     }
-
-    tiling_count++;
   }
-
-  EXPECT_EQ(tiling_count, 5);
 }
 
 TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
@@ -4210,24 +4071,23 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  SetupTrees(pending_pile, active_pile);
+
+  host_impl_.SetViewportSize(viewport_size);
+  SetupPendingTree(active_pile);
 
   // Partially occlude the active layer.
-  active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
-  LayerImpl* layer1 = active_layer_->children()[0];
+  pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
+  LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetContentBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
-  // Partially invalidate the pending layer.
-  pending_layer_->set_invalidation(invalidation_rect);
-
-  host_impl_.SetViewportSize(viewport_size);
+  ActivateTree();
 
-  active_layer_->CreateDefaultTilingsAndTiles();
-  pending_layer_->CreateDefaultTilingsAndTiles();
+  // Partially invalidate the pending layer.
+  SetupPendingTreeWithInvalidation(pending_pile, invalidation_rect);
 
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
@@ -4306,36 +4166,45 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
 
 TEST_F(OcclusionTrackingPictureLayerImplTest,
        OccludedTilesConsideredDuringEviction) {
+  base::TimeTicks time_ticks;
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+
   gfx::Size tile_size(102, 102);
   gfx::Size layer_bounds(1000, 1000);
-  gfx::Size viewport_size(500, 500);
+  gfx::Size viewport_size(1000, 1000);
   gfx::Point pending_occluding_layer_position(310, 0);
   gfx::Point active_occluding_layer_position(0, 310);
   gfx::Rect invalidation_rect(230, 230, 102, 102);
 
+  host_impl_.SetViewportSize(viewport_size);
+  host_impl_.SetDeviceScaleFactor(2.f);
+
   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);
 
-  pending_layer_->set_fixed_tile_size(tile_size);
-  active_layer_->set_fixed_tile_size(tile_size);
+  SetupPendingTreeWithFixedTileSize(active_pile, tile_size, Region());
 
-  float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
+  // Partially occlude the active layer.
+  pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
+  LayerImpl* active_occluding_layer = pending_layer_->children()[0];
+  active_occluding_layer->SetBounds(layer_bounds);
+  active_occluding_layer->SetContentBounds(layer_bounds);
+  active_occluding_layer->SetDrawsContent(true);
+  active_occluding_layer->SetContentsOpaque(true);
+  active_occluding_layer->SetPosition(active_occluding_layer_position);
 
-  std::vector<PictureLayerTiling*> tilings;
-  tilings.push_back(pending_layer_->AddTiling(low_res_factor));
-  tilings.push_back(pending_layer_->AddTiling(0.3f));
-  tilings.push_back(pending_layer_->AddTiling(0.7f));
-  tilings.push_back(pending_layer_->AddTiling(1.0f));
-  tilings.push_back(pending_layer_->AddTiling(2.0f));
+  ActivateTree();
 
-  EXPECT_EQ(5u, pending_layer_->num_tilings());
-  EXPECT_EQ(5u, active_layer_->num_tilings());
+  // Partially invalidate the pending layer. Tiles inside the invalidation rect
+  // are not shared between trees.
+  SetupPendingTreeWithFixedTileSize(pending_pile, tile_size, invalidation_rect);
 
-  // Partially occlude the pending layer.
-  pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
+  // Partially occlude the pending layer in a different way.
+  pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 3));
   LayerImpl* pending_occluding_layer = pending_layer_->children()[0];
   pending_occluding_layer->SetBounds(layer_bounds);
   pending_occluding_layer->SetContentBounds(layer_bounds);
@@ -4343,52 +4212,42 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   pending_occluding_layer->SetContentsOpaque(true);
   pending_occluding_layer->SetPosition(pending_occluding_layer_position);
 
-  // Partially occlude the active layer.
-  active_layer_->AddChild(LayerImpl::Create(host_impl_.active_tree(), 2));
-  LayerImpl* active_occluding_layer = active_layer_->children()[0];
-  active_occluding_layer->SetBounds(layer_bounds);
-  active_occluding_layer->SetContentBounds(layer_bounds);
-  active_occluding_layer->SetDrawsContent(true);
-  active_occluding_layer->SetContentsOpaque(true);
-  active_occluding_layer->SetPosition(active_occluding_layer_position);
+  EXPECT_EQ(2u, pending_layer_->num_tilings());
+  EXPECT_EQ(2u, active_layer_->num_tilings());
 
-  // Partially invalidate the pending layer. Tiles inside the invalidation rect
-  // are not shared between trees.
-  pending_layer_->set_invalidation(invalidation_rect);
-
-  host_impl_.SetViewportSize(viewport_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
+  time_ticks += base::TimeDelta::FromMilliseconds(1);
+  host_impl_.SetCurrentBeginFrameArgs(
+      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, time_ticks));
+  // UpdateDrawProperties with the occluding layer.
   host_impl_.pending_tree()->UpdateDrawProperties();
 
-  // The expected number of occluded tiles on each of the 5 tilings for each of
+  // The expected number of occluded tiles on each of the 2 tilings for each of
   // the 3 tree priorities.
-  size_t expected_occluded_tile_count_on_both[] = {9u, 1u, 1u, 1u, 1u};
-  size_t expected_occluded_tile_count_on_active[] = {30u, 5u, 4u, 2u, 2u};
-  size_t expected_occluded_tile_count_on_pending[] = {30u, 5u, 4u, 2u, 2u};
+  size_t expected_occluded_tile_count_on_both[] = {9u, 1u};
+  size_t expected_occluded_tile_count_on_active[] = {30u, 3u};
+  size_t expected_occluded_tile_count_on_pending[] = {30u, 3u};
 
   // The total expected number of occluded tiles on all tilings for each of the
   // 3 tree priorities.
-  size_t total_expected_occluded_tile_count[] = {13u, 43u, 43u};
+  size_t total_expected_occluded_tile_count[] = {10u, 33u, 33u};
 
   ASSERT_EQ(arraysize(total_expected_occluded_tile_count), NUM_TREE_PRIORITIES);
 
   // Verify number of occluded tiles on the pending layer for each tiling.
   for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
-    tiling->CreateAllTilesForTesting();
     tiling->UpdateAllTilePrioritiesForTesting();
 
     size_t occluded_tile_count_on_pending = 0u;
     size_t occluded_tile_count_on_active = 0u;
     size_t occluded_tile_count_on_both = 0u;
-    for (PictureLayerTiling::CoverageIterator iter(
-             tiling,
-             pending_layer_->contents_scale_x(),
-             gfx::Rect(layer_bounds));
-         iter;
-         ++iter) {
+    for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
+                                                   gfx::Rect(layer_bounds));
+         iter; ++iter) {
       Tile* tile = *iter;
 
+      if (!tile)
+        continue;
       if (tile->is_occluded(PENDING_TREE))
         occluded_tile_count_on_pending++;
       if (tile->is_occluded(ACTIVE_TREE))
@@ -4398,19 +4257,18 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
     }
     EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
               occluded_tile_count_on_pending)
-        << i;
+        << tiling->contents_scale();
     EXPECT_EQ(expected_occluded_tile_count_on_active[i],
               occluded_tile_count_on_active)
-        << i;
+        << tiling->contents_scale();
     EXPECT_EQ(expected_occluded_tile_count_on_both[i],
               occluded_tile_count_on_both)
-        << i;
+        << tiling->contents_scale();
   }
 
   // Verify number of occluded tiles on the active layer for each tiling.
   for (size_t i = 0; i < active_layer_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer_->tilings()->tiling_at(i);
-    tiling->CreateAllTilesForTesting();
     tiling->UpdateAllTilePrioritiesForTesting();
 
     size_t occluded_tile_count_on_pending = 0u;
@@ -4424,6 +4282,8 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
          ++iter) {
       Tile* tile = *iter;
 
+      if (!tile)
+        continue;
       if (tile->is_occluded(PENDING_TREE))
         occluded_tile_count_on_pending++;
       if (tile->is_occluded(ACTIVE_TREE))
@@ -4443,12 +4303,10 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
   }
 
   std::vector<Tile*> all_tiles;
-  for (std::vector<PictureLayerTiling*>::iterator tiling_iterator =
-           tilings.begin();
-       tiling_iterator != tilings.end();
-       ++tiling_iterator) {
-    std::vector<Tile*> tiles = (*tiling_iterator)->AllTilesForTesting();
-    std::copy(tiles.begin(), tiles.end(), std::back_inserter(all_tiles));
+  for (size_t i = 0; i < pending_layer_->num_tilings(); ++i) {
+    PictureLayerTiling* tiling = pending_layer_->tilings()->tiling_at(i);
+    std::vector<Tile*> tiles = tiling->AllTilesForTesting();
+    all_tiles.insert(all_tiles.end(), tiles.begin(), tiles.end());
   }
 
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(all_tiles);
@@ -4530,8 +4388,6 @@ void PictureLayerImplTest::TestQuadsForSolidColor(bool test_for_solid) {
   host->SetRootLayer(layer);
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(!test_for_solid);
@@ -4544,11 +4400,9 @@ void PictureLayerImplTest::TestQuadsForSolidColor(bool test_for_solid) {
   scoped_refptr<RasterSource> pending_raster_source =
       recording_source->CreateRasterSource();
 
-  SetupPendingTree(pending_raster_source);
+  SetupPendingTreeWithFixedTileSize(pending_raster_source, tile_size, Region());
   ActivateTree();
 
-  active_layer_->set_fixed_tile_size(tile_size);
-  host_impl_.active_tree()->UpdateDrawProperties();
   if (test_for_solid) {
     EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
   } else {
@@ -4597,8 +4451,6 @@ TEST_F(PictureLayerImplTest, NonSolidToSolidNoTilings) {
   host->SetRootLayer(layer);
   RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
-  host_impl_.SetViewportSize(layer_bounds);
-
   int frame_number = 0;
 
   client.set_fill_with_nonsolid_color(true);