cc: Added raster source.

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 159 matching lines @@
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
-      EXPECT_EQ(pile, iter->picture_pile());
+      EXPECT_EQ(pile, iter->raster_source());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     float maximum_animation_contents_scale,
                                     bool animating_transform) {
     SetupDrawPropertiesAndUpdateTiles(pending_layer_,
                                       contents_scale,
@@ skipping 331 matching lines @@
         tiling->contents_scale());
     for (PictureLayerTiling::CoverageIterator iter(
              tiling,
              tiling->contents_scale(),
              gfx::Rect(tiling->tiling_size()));
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
-        EXPECT_EQ(pending_pile.get(), iter->picture_pile());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
       else
-        EXPECT_EQ(active_pile.get(), iter->picture_pile());
+        EXPECT_EQ(active_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);
@@ skipping 46 matching lines @@
          ++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->picture_pile());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
       } else {
-        EXPECT_EQ(active_pile.get(), iter->picture_pile());
+        EXPECT_EQ(active_pile.get(), iter->raster_source());
       }
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
@@ skipping 32 matching lines @@
          iter;
          ++iter) {
       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
       // Ensure there is a recording for this tile.
       bool in_pending = pending_pile->CanRaster(tiling->contents_scale(),
                                                 iter.full_tile_geometry_rect());
       bool in_active = active_pile->CanRaster(tiling->contents_scale(),
                                               iter.full_tile_geometry_rect());
 
       if (in_pending && !in_active)
-        EXPECT_EQ(pending_pile.get(), iter->picture_pile());
+        EXPECT_EQ(pending_pile.get(), iter->raster_source());
       else if (in_active)
-        EXPECT_EQ(active_pile.get(), iter->picture_pile());
+        EXPECT_EQ(active_pile.get(), iter->raster_source());
       else
         EXPECT_FALSE(*iter);
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
@@ skipping 3978 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