Update from chromium https://crrev.com/301725/

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/refptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 19 matching lines @@
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
   SkPaint non_solid_paint;
   non_solid_paint.setColor(non_solid_color);
 
   pile->add_draw_rect_with_paint(gfx::Rect(0, 0, 400, 400), solid_paint);
   pile->RerecordPile();
 
   // Ensure everything is solid
   for (int y = 0; y <= 300; y += 100) {
     for (int x = 0; x <= 300; x += 100) {
-      PicturePileImpl::Analysis analysis;
+      RasterSource::SolidColorAnalysis analysis;
       gfx::Rect rect(x, y, 100, 100);
-      pile->AnalyzeInRect(rect, 1.0, &analysis);
+      pile->PerformSolidColorAnalysis(rect, 1.0, &analysis, nullptr);
       EXPECT_TRUE(analysis.is_solid_color) << rect.ToString();
       EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString();
     }
   }
 
   // One pixel non solid
   pile->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1), non_solid_paint);
   pile->RerecordPile();
 
-  PicturePileImpl::Analysis analysis;
-  pile->AnalyzeInRect(gfx::Rect(0, 0, 100, 100), 1.0, &analysis);
+  RasterSource::SolidColorAnalysis analysis;
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 0, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_FALSE(analysis.is_solid_color);
 
-  pile->AnalyzeInRect(gfx::Rect(100, 0, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(100, 0, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   // Boundaries should be clipped
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(350, 0, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(350, 0, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(0, 350, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 350, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(350, 350, 100, 100), 1.0, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(350, 350, 100, 100), 1.0, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 }
 
 TEST(PicturePileImplTest, AnalyzeIsSolidScaled) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SkColor solid_color = SkColorSetARGB(255, 12, 23, 34);
   SkPaint solid_paint;
   solid_paint.setColor(solid_color);
 
   SkColor non_solid_color = SkColorSetARGB(128, 45, 56, 67);
   SkPaint non_solid_paint;
   non_solid_paint.setColor(non_solid_color);
 
   pile->add_draw_rect_with_paint(gfx::Rect(0, 0, 400, 400), solid_paint);
   pile->RerecordPile();
 
   // Ensure everything is solid
   for (int y = 0; y <= 30; y += 10) {
     for (int x = 0; x <= 30; x += 10) {
-      PicturePileImpl::Analysis analysis;
+      RasterSource::SolidColorAnalysis analysis;
       gfx::Rect rect(x, y, 10, 10);
-      pile->AnalyzeInRect(rect, 0.1f, &analysis);
+      pile->PerformSolidColorAnalysis(rect, 0.1f, &analysis, nullptr);
       EXPECT_TRUE(analysis.is_solid_color) << rect.ToString();
       EXPECT_EQ(analysis.solid_color, solid_color) << rect.ToString();
     }
   }
 
   // One pixel non solid
   pile->add_draw_rect_with_paint(gfx::Rect(50, 50, 1, 1), non_solid_paint);
   pile->RerecordPile();
 
-  PicturePileImpl::Analysis analysis;
-  pile->AnalyzeInRect(gfx::Rect(0, 0, 10, 10), 0.1f, &analysis);
+  RasterSource::SolidColorAnalysis analysis;
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 0, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_FALSE(analysis.is_solid_color);
 
-  pile->AnalyzeInRect(gfx::Rect(10, 0, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(10, 0, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   // Boundaries should be clipped
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(35, 0, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(35, 0, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(0, 35, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 35, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 
   analysis.is_solid_color = false;
-  pile->AnalyzeInRect(gfx::Rect(35, 35, 10, 10), 0.1f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(35, 35, 10, 10), 0.1f, &analysis, nullptr);
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, solid_color);
 }
 
 TEST(PicturePileImplTest, AnalyzeIsSolidEmpty) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  PicturePileImpl::Analysis analysis;
+  RasterSource::SolidColorAnalysis analysis;
   EXPECT_FALSE(analysis.is_solid_color);
 
-  pile->AnalyzeInRect(gfx::Rect(0, 0, 400, 400), 1.f, &analysis);
+  pile->PerformSolidColorAnalysis(
+      gfx::Rect(0, 0, 400, 400), 1.f, &analysis, nullptr);
 
   EXPECT_TRUE(analysis.is_solid_color);
   EXPECT_EQ(analysis.solid_color, SkColorSetARGB(0, 0, 0, 0));
 }
 
 TEST(PicturePileImplTest, PixelRefIteratorEmpty) {
   gfx::Size tile_size(128, 128);
   gfx::Size layer_bounds(256, 256);
 
   // Create a filled pile with no recording.
@@ skipping 525 matching lines @@
       gfx::Rect canvas_rect(content_rect);
       canvas_rect.Inset(0, 0, -1, -1);
 
       SkBitmap bitmap;
       bitmap.allocN32Pixels(canvas_rect.width(), canvas_rect.height());
       SkCanvas canvas(bitmap);
       canvas.clear(SK_ColorTRANSPARENT);
 
       FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
 
-      pile->RasterToBitmap(&canvas,
-                           canvas_rect,
-                           contents_scale,
-                           &rendering_stats_instrumentation);
+      pile->PlaybackToCanvas(&canvas,
+                             canvas_rect,
+                             contents_scale,
+                             &rendering_stats_instrumentation);
 
       SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
       int num_pixels = bitmap.width() * bitmap.height();
       bool all_white = true;
       for (int i = 0; i < num_pixels; ++i) {
         EXPECT_EQ(SkColorGetA(pixels[i]), 255u);
         all_white &= (SkColorGetR(pixels[i]) == 255);
         all_white &= (SkColorGetG(pixels[i]) == 255);
         all_white &= (SkColorGetB(pixels[i]) == 255);
       }
@@ skipping 27 matching lines @@
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale)));
 
   gfx::Rect canvas_rect(content_bounds);
   canvas_rect.Inset(0, 0, -1, -1);
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(canvas_rect.width(), canvas_rect.height());
   SkCanvas canvas(bitmap);
 
   FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
-  pile->RasterToBitmap(
+  pile->PlaybackToCanvas(
       &canvas, canvas_rect, contents_scale, &rendering_stats_instrumentation);
 
   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);
   }
 }
 
 class OverlapTest : public ::testing::TestWithParam<float> {
@@ skipping 25 matching lines @@
   pile->RerecordPile();
 
   gfx::Size content_bounds(
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale)));
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(content_bounds.width(), content_bounds.height());
   SkCanvas canvas(bitmap);
 
   FakeRenderingStatsInstrumentation rendering_stats_instrumentation;
-  pile->RasterToBitmap(&canvas,
-                       gfx::Rect(content_bounds),
-                       contents_scale,
-                       &rendering_stats_instrumentation);
+  pile->PlaybackToCanvas(&canvas,
+                         gfx::Rect(content_bounds),
+                         contents_scale,
+                         &rendering_stats_instrumentation);
 
   for (int y = 0; y < bitmap.height(); y++) {
     for (int x = 0; x < bitmap.width(); x++) {
       SkColor color = bitmap.getColor(x, y);
       EXPECT_EQ(SkColorGetR(test_color), SkColorGetR(color)) << "x: " << x
                                                              << ", y: " << y;
       EXPECT_EQ(SkColorGetG(test_color), SkColorGetG(color)) << "x: " << x
                                                              << ", y: " << y;
       EXPECT_EQ(SkColorGetB(test_color), SkColorGetB(color)) << "x: " << x
                                                              << ", y: " << y;
@@ skipping 82 matching lines @@
     EXPECT_TRUE(iterator);
     EXPECT_TRUE(*iterator == discardable_bitmap[1].pixelRef());
     EXPECT_TRUE(++iterator);
     EXPECT_TRUE(*iterator == discardable_bitmap[2].pixelRef());
     EXPECT_FALSE(++iterator);
   }
 }
 
 }  // namespace
 }  // namespace cc