Update from https://crrev.com/304121

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 116 matching lines @@
     active_layer_->AddTiling(2.3f);
     active_layer_->AddTiling(1.0f);
     active_layer_->AddTiling(0.5f);
     for (size_t i = 0; i < active_layer_->tilings()->num_tilings(); ++i)
       active_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
     pending_layer_->set_invalidation(invalidation);
     for (size_t i = 0; i < pending_layer_->tilings()->num_tilings(); ++i)
       pending_layer_->tilings()->tiling_at(i)->CreateAllTilesForTesting();
   }
 
-  void SetupPendingTree(scoped_refptr<PicturePileImpl> pile) {
+  void SetupPendingTree(scoped_refptr<RasterSource> raster_source) {
     host_impl_.CreatePendingTree();
     host_impl_.pending_tree()->SetPageScaleFactorAndLimits(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_);
 
     scoped_ptr<FakePictureLayerImpl> pending_layer;
     if (old_pending_root) {
       pending_layer.reset(
           static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
-      pending_layer->SetPile(pile);
+      pending_layer->SetRasterSource(raster_source);
     } else {
-      pending_layer =
-          FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pile);
+      pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
+          pending_tree, id_, raster_source);
       pending_layer->SetDrawsContent(true);
     }
     // The bounds() just mirror the pile size.
-    pending_layer->SetBounds(pending_layer->pile()->tiling_size());
+    pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
     pending_tree->SetRootLayer(pending_layer.Pass());
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
     pending_layer_->DoPostCommitInitializationIfNeeded();
   }
 
   void SetupDrawPropertiesAndUpdateTiles(FakePictureLayerImpl* layer,
                                          float ideal_contents_scale,
                                          float device_scale_factor,
@@ skipping 93 matching lines @@
       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->RasterDirect(&mock_canvas, (*tile_iter)->content_rect(),
-                                1.0f);
+      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++;
     }
   }
@@ skipping 368 matching lines @@
     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->CanRaster(tiling->contents_scale(),
-                                                iter.full_tile_geometry_rect());
-      bool in_active = active_pile->CanRaster(tiling->contents_scale(),
-                                              iter.full_tile_geometry_rect());
+      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);
     }
   }
 }
@@ skipping 450 matching lines @@
                                device_scale,
                                page_scale,
                                maximum_animation_scale,
                                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);
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
-  gfx::Size tile_size(host_impl_.settings().default_tile_size);
-  SetupDefaultTrees(tile_size);
+  gfx::Size layer_bounds(host_impl_.settings().default_tile_size);
+  gfx::Size tile_size(100, 100);
+
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+
+  SetupTrees(pending_pile, active_pile);
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   bool animating_transform = false;
 
   // Contents exactly fit on one tile at scale 1, no low res.
   float contents_scale = 1.f;
   SetContentsScaleOnBothLayers(contents_scale,
@@ skipping 27 matching lines @@
                                maximum_animation_scale,
                                animating_transform);
   EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
   EXPECT_BOTH_EQ(LowResTiling()->contents_scale(),
                  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_->pile()->set_is_mask(true);
-  active_layer_->pile()->set_is_mask(true);
+  pending_pile->SetIsMask(true);
+  active_pile->SetIsMask(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);
 }
 
 TEST_F(PictureLayerImplTest, HugeMasksDontGetTiles) {
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
-  valid_pile->set_is_mask(true);
+  valid_pile->SetIsMask(true);
   SetupPendingTree(valid_pile);
 
   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());
 
   pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_layer_->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   // Mask layers have a tiling with a single tile in it.
   EXPECT_EQ(1u, active_layer_->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);
   EXPECT_NE(0u, mask_resource_id);
   EXPECT_EQ(mask_texture_size, active_layer_->bounds());
 
   // Resize larger than the max texture size.
   int max_texture_size = host_impl_.GetRendererCapabilities().max_texture_size;
   scoped_refptr<FakePicturePileImpl> huge_pile =
       FakePicturePileImpl::CreateFilledPile(
           tile_size, gfx::Size(max_texture_size + 1, 10));
-  huge_pile->set_is_mask(true);
+  huge_pile->SetIsMask(true);
   SetupPendingTree(huge_pile);
 
   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());
 
   pending_layer_->HighResTiling()->CreateAllTilesForTesting();
   host_impl_.tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_layer_->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   // Mask layers have a tiling, but there should be no tiles in it.
   EXPECT_EQ(0u, active_layer_->HighResTiling()->AllTilesForTesting().size());
   // The mask resource is empty.
   active_layer_->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
   EXPECT_EQ(0u, mask_resource_id);
 }
 
 TEST_F(PictureLayerImplTest, ScaledMaskLayer) {
   gfx::Size tile_size(100, 100);
 
   scoped_refptr<FakePicturePileImpl> valid_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
-  valid_pile->set_is_mask(true);
+  valid_pile->SetIsMask(true);
   SetupPendingTree(valid_pile);
 
   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());
 
   pending_layer_->HighResTiling()->CreateAllTilesForTesting();
@@ skipping 229 matching lines @@
   // 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();
   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_->UpdatePile(pending_pile);
+  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();
   EXPECT_TRUE(active_layer_->CanHaveTilings());
   EXPECT_GT(active_layer_->ideal_contents_scale(), 0.f);
 }
 
 TEST_F(PictureLayerImplTest, MarkRequiredOffscreenTiles) {
   gfx::Size tile_size(100, 100);
@@ skipping 524 matching lines @@
 TEST_F(PictureLayerImplTest, ActivateUninitializedLayer) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   host_impl_.CreatePendingTree();
   LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
   scoped_ptr<FakePictureLayerImpl> pending_layer =
-      FakePictureLayerImpl::CreateWithPile(pending_tree, id_, pending_pile);
+      FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
+                                                   pending_pile);
   pending_layer->SetDrawsContent(true);
   pending_tree->SetRootLayer(pending_layer.Pass());
 
   pending_layer_ = static_cast<FakePictureLayerImpl*>(
       host_impl_.pending_tree()->LayerById(id_));
 
   // Set some state on the pending layer, make sure it is not clobbered
   // by a sync from the active layer.  This could happen because if the
   // pending layer has not been post-commit initialized it will attempt
   // to sync from the active layer.
@@ skipping 1643 matching lines @@
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.pending_tree(), 1);
 
   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);
-  pending_pile->set_is_mask(true);
-  scoped_ptr<FakePictureLayerImpl> mask = FakePictureLayerImpl::CreateWithPile(
-      host_impl_.pending_tree(), 3, pending_pile);
+  pending_pile->SetIsMask(true);
+  scoped_ptr<FakePictureLayerImpl> mask =
+      FakePictureLayerImpl::CreateWithRasterSource(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());
 
   scoped_ptr<FakePictureLayerImpl> child_of_layer_with_mask =
       FakePictureLayerImpl::Create(host_impl_.pending_tree(), 4);
@@ skipping 754 matching lines @@
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Rect layer_rect(layer_bounds);
 
   FakeContentLayerClient client;
   scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
   FakeLayerTreeHostClient host_client(FakeLayerTreeHostClient::DIRECT_3D);
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&host_client);
   host->SetRootLayer(layer);
-  PicturePile* pile = layer->GetPicturePileForTesting();
+  RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   host_impl_.SetViewportSize(layer_bounds);
 
   int frame_number = 0;
-  FakeRenderingStatsInstrumentation stats_instrumentation;
 
   client.set_fill_with_nonsolid_color(!test_for_solid);
 
   Region invalidation(layer_rect);
-  pile->UpdateAndExpandInvalidation(&client,
-                                    &invalidation,
-                                    SK_ColorWHITE,
-                                    false,
-                                    false,
-                                    layer_bounds,
-                                    layer_rect,
-                                    frame_number++,
-                                    Picture::RECORD_NORMALLY,
-                                    &stats_instrumentation);
+  recording_source->UpdateAndExpandInvalidation(
+      &client, &invalidation, SK_ColorWHITE, false, false, layer_bounds,
+      layer_rect, frame_number++, Picture::RECORD_NORMALLY);
 
-  scoped_refptr<PicturePileImpl> pending_pile =
-      PicturePileImpl::CreateFromOther(pile);
+  scoped_refptr<RasterSource> pending_raster_source =
+      recording_source->CreateRasterSource();
 
-  SetupPendingTree(pending_pile);
+  SetupPendingTree(pending_raster_source);
   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 {
     ASSERT_TRUE(active_layer_->tilings());
     ASSERT_GT(active_layer_->tilings()->num_tilings(), 0u);
     std::vector<Tile*> tiles =
@@ skipping 30 matching lines @@
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(200, 200);
   gfx::Rect layer_rect(layer_bounds);
 
   FakeContentLayerClient client;
   scoped_refptr<PictureLayer> layer = PictureLayer::Create(&client);
   FakeLayerTreeHostClient host_client(FakeLayerTreeHostClient::DIRECT_3D);
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&host_client);
   host->SetRootLayer(layer);
-  PicturePile* pile = layer->GetPicturePileForTesting();
+  RecordingSource* recording_source = layer->GetRecordingSourceForTesting();
 
   host_impl_.SetViewportSize(layer_bounds);
 
   int frame_number = 0;
-  FakeRenderingStatsInstrumentation stats_instrumentation;
 
   client.set_fill_with_nonsolid_color(true);
 
   Region invalidation1(layer_rect);
-  pile->UpdateAndExpandInvalidation(&client,
-                                    &invalidation1,
-                                    SK_ColorWHITE,
-                                    false,
-                                    false,
-                                    layer_bounds,
-                                    layer_rect,
-                                    frame_number++,
-                                    Picture::RECORD_NORMALLY,
-                                    &stats_instrumentation);
+  recording_source->UpdateAndExpandInvalidation(
+      &client, &invalidation1, SK_ColorWHITE, false, false, layer_bounds,
+      layer_rect, frame_number++, Picture::RECORD_NORMALLY);
 
-  scoped_refptr<PicturePileImpl> pending_pile1 =
-      PicturePileImpl::CreateFromOther(pile);
+  scoped_refptr<RasterSource> raster_source1 =
+      recording_source->CreateRasterSource();
 
-  SetupPendingTree(pending_pile1);
+  SetupPendingTree(raster_source1);
   ActivateTree();
   host_impl_.active_tree()->UpdateDrawProperties();
 
   // We've started with a solid layer that contains some tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_NE(0u, active_layer_->tilings()->num_tilings());
 
   client.set_fill_with_nonsolid_color(false);
 
   Region invalidation2(layer_rect);
-  pile->UpdateAndExpandInvalidation(&client,
-                                    &invalidation2,
-                                    SK_ColorWHITE,
-                                    false,
-                                    false,
-                                    layer_bounds,
-                                    layer_rect,
-                                    frame_number++,
-                                    Picture::RECORD_NORMALLY,
-                                    &stats_instrumentation);
+  recording_source->UpdateAndExpandInvalidation(
+      &client, &invalidation2, SK_ColorWHITE, false, false, layer_bounds,
+      layer_rect, frame_number++, Picture::RECORD_NORMALLY);
 
-  scoped_refptr<PicturePileImpl> pending_pile2 =
-      PicturePileImpl::CreateFromOther(pile);
+  scoped_refptr<RasterSource> raster_source2 =
+      recording_source->CreateRasterSource();
 
-  SetupPendingTree(pending_pile2);
+  SetupPendingTree(raster_source2);
   ActivateTree();
 
   // We've switched to a solid color, so we should end up with no tilings.
   ASSERT_TRUE(active_layer_->tilings());
   EXPECT_EQ(0u, active_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ChangeInViewportAllowsTilingUpdates) {
   base::TimeTicks time_ticks;
   time_ticks += base::TimeDelta::FromMilliseconds(1);
@@ skipping 113 matching lines @@
   result = layer->CalculateTileSize(gfx::Size(447, 400));
   EXPECT_EQ(result.width(), 448);
   EXPECT_EQ(result.height(), 448);
   result = layer->CalculateTileSize(gfx::Size(500, 499));
   EXPECT_EQ(result.width(), 512);
   EXPECT_EQ(result.height(), 500 + 2);
 }
 
 }  // namespace
 }  // namespace cc