cc: Gather and lock/unlock SkDiscardablePixelRefs instead of skia::LazyPixelRefs.

cc/resources/picture_pile_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 "base/memory/scoped_ptr.h"
 #include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/fake_rendering_stats_instrumentation.h"
 #include "cc/test/skia_common.h"
-#include "skia/ext/lazy_pixel_ref.h"
 #include "skia/ext/refptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkPixelRef.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
 
@@ skipping 179 matching lines @@
         gfx::Rect(0, 0, 512, 512), 2.0, pile.get());
     EXPECT_FALSE(iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 0.5, pile.get());
     EXPECT_FALSE(iterator);
   }
 }
 
-TEST(PicturePileImplTest, PixelRefIteratorNoLazyRefs) {
+TEST(PicturePileImplTest, PixelRefIteratorNoDiscardableRefs) {
   gfx::Size tile_size(128, 128);
   gfx::Size layer_bounds(256, 256);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SkPaint simple_paint;
   simple_paint.setColor(SkColorSetARGB(255, 12, 23, 34));
 
-  SkBitmap non_lazy_bitmap;
-  CreateBitmap(gfx::Size(128, 128), "notlazy", &non_lazy_bitmap);
+  SkBitmap non_discardable_bitmap;
+  CreateBitmap(gfx::Size(128, 128), "notdiscardable", &non_discardable_bitmap);
 
   pile->add_draw_rect_with_paint(gfx::Rect(0, 0, 256, 256), simple_paint);
   pile->add_draw_rect_with_paint(gfx::Rect(128, 128, 512, 512), simple_paint);
   pile->add_draw_rect_with_paint(gfx::Rect(512, 0, 256, 256), simple_paint);
   pile->add_draw_rect_with_paint(gfx::Rect(0, 512, 256, 256), simple_paint);
-  pile->add_draw_bitmap(non_lazy_bitmap, gfx::Point(128, 0));
-  pile->add_draw_bitmap(non_lazy_bitmap, gfx::Point(0, 128));
-  pile->add_draw_bitmap(non_lazy_bitmap, gfx::Point(150, 150));
+  pile->add_draw_bitmap(non_discardable_bitmap, gfx::Point(128, 0));
+  pile->add_draw_bitmap(non_discardable_bitmap, gfx::Point(0, 128));
+  pile->add_draw_bitmap(non_discardable_bitmap, gfx::Point(150, 150));
 
   pile->RerecordPile();
 
   // Tile sized iterators.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 1.0, pile.get());
     EXPECT_FALSE(iterator);
   }
   {
@@ skipping 33 matching lines @@
         gfx::Rect(0, 0, 512, 512), 2.0, pile.get());
     EXPECT_FALSE(iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 0.5, pile.get());
     EXPECT_FALSE(iterator);
   }
 }
 
-TEST(PicturePileImplTest, PixelRefIteratorLazyRefs) {
+TEST(PicturePileImplTest, PixelRefIteratorDiscardableRefs) {
   gfx::Size tile_size(128, 128);
   gfx::Size layer_bounds(256, 256);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SkBitmap lazy_bitmap[2][2];
-  CreateBitmap(gfx::Size(32, 32), "lazy", &lazy_bitmap[0][0]);
-  CreateBitmap(gfx::Size(32, 32), "lazy", &lazy_bitmap[1][0]);
-  CreateBitmap(gfx::Size(32, 32), "lazy", &lazy_bitmap[1][1]);
+  SkBitmap discardable_bitmap[2][2];
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[0][0]);
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[1][0]);
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[1][1]);
 
-  // Lazy pixel refs are found in the following cells:
+  // Discardable pixel refs are found in the following cells:
   // |---|---|
   // | x |   |
   // |---|---|
   // | x | x |
   // |---|---|
-  pile->add_draw_bitmap(lazy_bitmap[0][0], gfx::Point(0, 0));
-  pile->add_draw_bitmap(lazy_bitmap[1][0], gfx::Point(0, 130));
-  pile->add_draw_bitmap(lazy_bitmap[1][1], gfx::Point(140, 140));
+  pile->add_draw_bitmap(discardable_bitmap[0][0], gfx::Point(0, 0));
+  pile->add_draw_bitmap(discardable_bitmap[1][0], gfx::Point(0, 130));
+  pile->add_draw_bitmap(discardable_bitmap[1][1], gfx::Point(140, 140));
 
   pile->RerecordPile();
 
   // Tile sized iterators. These should find only one pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 256, 256), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 64, 64), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   // Shifted tile sized iterators. These should find only one pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(140, 140, 128, 128), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(280, 280, 256, 256), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(70, 70, 64, 64), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
-  // Ensure there's no lazy pixel refs in the empty cell
+  // Ensure there's no discardable pixel refs in the empty cell
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(140, 0, 128, 128), 1.0, pile.get());
     EXPECT_FALSE(iterator);
   }
   // Layer sized iterators. These should find all 3 pixel refs.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 256, 256), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 512, 512), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
 }
 
-TEST(PicturePileImplTest, PixelRefIteratorLazyRefsOneTile) {
+TEST(PicturePileImplTest, PixelRefIteratorDiscardableRefsOneTile) {
   gfx::Size tile_size(256, 256);
   gfx::Size layer_bounds(512, 512);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SkBitmap lazy_bitmap[2][2];
-  CreateBitmap(gfx::Size(32, 32), "lazy", &lazy_bitmap[0][0]);
-  CreateBitmap(gfx::Size(32, 32), "lazy", &lazy_bitmap[0][1]);
-  CreateBitmap(gfx::Size(32, 32), "lazy", &lazy_bitmap[1][1]);
+  SkBitmap discardable_bitmap[2][2];
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[0][0]);
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[0][1]);
+  CreateBitmap(gfx::Size(32, 32), "discardable", &discardable_bitmap[1][1]);
 
-  // Lazy pixel refs are found in the following cells:
+  // Discardable pixel refs are found in the following cells:
   // |---|---|
   // | x | x |
   // |---|---|
   // |   | x |
   // |---|---|
-  pile->add_draw_bitmap(lazy_bitmap[0][0], gfx::Point(0, 0));
-  pile->add_draw_bitmap(lazy_bitmap[0][1], gfx::Point(260, 0));
-  pile->add_draw_bitmap(lazy_bitmap[1][1], gfx::Point(260, 260));
+  pile->add_draw_bitmap(discardable_bitmap[0][0], gfx::Point(0, 0));
+  pile->add_draw_bitmap(discardable_bitmap[0][1], gfx::Point(260, 0));
+  pile->add_draw_bitmap(discardable_bitmap[1][1], gfx::Point(260, 260));
 
   pile->RerecordPile();
 
   // Tile sized iterators. These should find only one pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 256, 256), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 512, 512), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   // Shifted tile sized iterators. These should find only one pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(260, 260, 256, 256), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(520, 520, 512, 512), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(130, 130, 128, 128), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
-  // Ensure there's no lazy pixel refs in the empty cell
+  // Ensure there's no discardable pixel refs in the empty cell
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 256, 256, 256), 1.0, pile.get());
     EXPECT_FALSE(iterator);
   }
   // Layer sized iterators. These should find three pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 512, 512), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 1024, 1024), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 256, 256), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
 
   // Copy test.
   PicturePileImpl::PixelRefIterator iterator(
       gfx::Rect(0, 0, 512, 512), 1.0, pile.get());
   EXPECT_TRUE(iterator);
-  EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+  EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
   EXPECT_TRUE(++iterator);
-  EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+  EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
 
   // copy now points to the same spot as iterator,
   // but both can be incremented independently.
   PicturePileImpl::PixelRefIterator copy = iterator;
   EXPECT_TRUE(++iterator);
-  EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+  EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
   EXPECT_FALSE(++iterator);
 
   EXPECT_TRUE(copy);
-  EXPECT_TRUE(*copy == lazy_bitmap[0][1].pixelRef());
+  EXPECT_TRUE(*copy == discardable_bitmap[0][1].pixelRef());
   EXPECT_TRUE(++copy);
-  EXPECT_TRUE(*copy == lazy_bitmap[1][1].pixelRef());
+  EXPECT_TRUE(*copy == discardable_bitmap[1][1].pixelRef());
   EXPECT_FALSE(++copy);
 }
 
-TEST(PicturePileImplTest, PixelRefIteratorLazyRefsBaseNonLazy) {
+TEST(PicturePileImplTest, PixelRefIteratorDiscardableRefsBaseNonDiscardable) {
   gfx::Size tile_size(256, 256);
   gfx::Size layer_bounds(512, 512);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
-  SkBitmap non_lazy_bitmap;
-  CreateBitmap(gfx::Size(512, 512), "notlazy", &non_lazy_bitmap);
+  SkBitmap non_discardable_bitmap;
+  CreateBitmap(gfx::Size(512, 512), "notdiscardable", &non_discardable_bitmap);
 
-  SkBitmap lazy_bitmap[2][2];
-  CreateBitmap(gfx::Size(128, 128), "lazy", &lazy_bitmap[0][0]);
-  CreateBitmap(gfx::Size(128, 128), "lazy", &lazy_bitmap[0][1]);
-  CreateBitmap(gfx::Size(128, 128), "lazy", &lazy_bitmap[1][1]);
+  SkBitmap discardable_bitmap[2][2];
+  CreateBitmap(gfx::Size(128, 128), "discardable", &discardable_bitmap[0][0]);
+  CreateBitmap(gfx::Size(128, 128), "discardable", &discardable_bitmap[0][1]);
+  CreateBitmap(gfx::Size(128, 128), "discardable", &discardable_bitmap[1][1]);
 
-  // One large non-lazy bitmap covers the whole grid.
-  // Lazy pixel refs are found in the following cells:
+  // One large non-discardable bitmap covers the whole grid.
+  // Discardable pixel refs are found in the following cells:
   // |---|---|
   // | x | x |
   // |---|---|
   // |   | x |
   // |---|---|
-  pile->add_draw_bitmap(non_lazy_bitmap, gfx::Point(0, 0));
-  pile->add_draw_bitmap(lazy_bitmap[0][0], gfx::Point(0, 0));
-  pile->add_draw_bitmap(lazy_bitmap[0][1], gfx::Point(260, 0));
-  pile->add_draw_bitmap(lazy_bitmap[1][1], gfx::Point(260, 260));
+  pile->add_draw_bitmap(non_discardable_bitmap, gfx::Point(0, 0));
+  pile->add_draw_bitmap(discardable_bitmap[0][0], gfx::Point(0, 0));
+  pile->add_draw_bitmap(discardable_bitmap[0][1], gfx::Point(260, 0));
+  pile->add_draw_bitmap(discardable_bitmap[1][1], gfx::Point(260, 260));
 
   pile->RerecordPile();
 
   // Tile sized iterators. These should find only one pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 256, 256), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 512, 512), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 128, 128), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   // Shifted tile sized iterators. These should find only one pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(260, 260, 256, 256), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(520, 520, 512, 512), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(130, 130, 128, 128), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
-  // Ensure there's no lazy pixel refs in the empty cell
+  // Ensure there's no discardable pixel refs in the empty cell
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 256, 256, 256), 1.0, pile.get());
     EXPECT_FALSE(iterator);
   }
   // Layer sized iterators. These should find three pixel ref.
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 512, 512), 1.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 1024, 1024), 2.0, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
   {
     PicturePileImpl::PixelRefIterator iterator(
         gfx::Rect(0, 0, 256, 256), 0.5, pile.get());
     EXPECT_TRUE(iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][0].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][0].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[0][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[0][1].pixelRef());
     EXPECT_TRUE(++iterator);
-    EXPECT_TRUE(*iterator == lazy_bitmap[1][1].pixelRef());
+    EXPECT_TRUE(*iterator == discardable_bitmap[1][1].pixelRef());
     EXPECT_FALSE(++iterator);
   }
 }
 
 TEST(PicturePileImpl, RasterContentsOpaque) {
   gfx::Size tile_size(1000, 1000);
   gfx::Size layer_bounds(3, 5);
   float contents_scale = 1.5f;
   float raster_divisions = 2.f;
 
@@ skipping 95 matching lines @@
 
   SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
   int num_pixels = bitmap.width() * bitmap.height();
   for (int i = 0; i < num_pixels; ++i) {
     EXPECT_EQ(SkColorGetA(pixels[i]), 0u);
   }
 }
 
 }  // namespace
 }  // namespace cc