cc/paint: Remove PaintCanvas::peekPixels.

ui/gfx/color_analysis_unittest.cc

 // Copyright (c) 2012 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 "ui/gfx/color_analysis.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ skipping 327 matching lines @@
 TEST_F(ColorAnalysisTest, ComputeColorCovarianceWithCanvas) {
   gfx::Canvas canvas(gfx::Size(250, 200), 1.0f, true);
   // The image consists of vertical stripes, with color bands set to 100
   // in overlapping stripes 150 pixels wide.
   canvas.FillRect(gfx::Rect(0, 0, 50, 200), SkColorSetRGB(100, 0, 0));
   canvas.FillRect(gfx::Rect(50, 0, 50, 200), SkColorSetRGB(100, 100, 0));
   canvas.FillRect(gfx::Rect(100, 0, 50, 200), SkColorSetRGB(100, 100, 100));
   canvas.FillRect(gfx::Rect(150, 0, 50, 200), SkColorSetRGB(0, 100, 100));
   canvas.FillRect(gfx::Rect(200, 0, 50, 200), SkColorSetRGB(0, 0, 100));
 
-  gfx::Matrix3F covariance = ComputeColorCovariance(canvas.ToBitmap());
+  gfx::Matrix3F covariance = ComputeColorCovariance(canvas.GetBitmap());
 
   gfx::Matrix3F expected_covariance = gfx::Matrix3F::Zeros();
   expected_covariance.set(2400, 400, -1600,
                           400, 2400, 400,
                           -1600, 400, 2400);
   EXPECT_EQ(expected_covariance, covariance);
 }
 
 TEST_F(ColorAnalysisTest, ApplyColorReductionSingleColor) {
   // The test runs color reduction on a single-colot image, where results are
@@ skipping 36 matching lines @@
 }
 
 TEST_F(ColorAnalysisTest, ApplyColorReductionBlackAndWhite) {
   // Check with images with multiple colors. This is really different only when
   // the result is scaled.
   gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
 
   // The image consists of vertical non-overlapping stripes 150 pixels wide.
   canvas.FillRect(gfx::Rect(0, 0, 150, 200), SkColorSetRGB(0, 0, 0));
   canvas.FillRect(gfx::Rect(150, 0, 150, 200), SkColorSetRGB(255, 255, 255));
-  SkBitmap source = canvas.ToBitmap();
+  SkBitmap source = canvas.GetBitmap();
   SkBitmap result;
   result.allocPixels(SkImageInfo::MakeA8(300, 200));
 
   gfx::Vector3dF transform(1.0f, 0.5f, 0.1f);
   EXPECT_TRUE(ApplyColorReduction(source, transform, true, &result));
   uint8_t min_gl = 0;
   uint8_t max_gl = 0;
   Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
 
   EXPECT_EQ(0, min_gl);
@@ skipping 16 matching lines @@
 
 TEST_F(ColorAnalysisTest, ApplyColorReductionMultiColor) {
   // Check with images with multiple colors. This is really different only when
   // the result is scaled.
   gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
 
   // The image consists of vertical non-overlapping stripes 100 pixels wide.
   canvas.FillRect(gfx::Rect(0, 0, 100, 200), SkColorSetRGB(100, 0, 0));
   canvas.FillRect(gfx::Rect(100, 0, 100, 200), SkColorSetRGB(0, 255, 0));
   canvas.FillRect(gfx::Rect(200, 0, 100, 200), SkColorSetRGB(0, 0, 128));
-  SkBitmap source = canvas.ToBitmap();
+  SkBitmap source = canvas.GetBitmap();
   SkBitmap result;
   result.allocPixels(SkImageInfo::MakeA8(300, 200));
 
   gfx::Vector3dF transform(1.0f, 0.5f, 0.1f);
   EXPECT_TRUE(ApplyColorReduction(source, transform, false, &result));
   uint8_t min_gl = 0;
   uint8_t max_gl = 0;
   Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
   EXPECT_EQ(12, min_gl);
   EXPECT_EQ(127, max_gl);
@@ skipping 21 matching lines @@
   EXPECT_FALSE(ComputePrincipalComponentImage(source, &result));
 }
 
 TEST_F(ColorAnalysisTest, ComputePrincipalComponentImage) {
   gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
 
   // The image consists of vertical non-overlapping stripes 100 pixels wide.
   canvas.FillRect(gfx::Rect(0, 0, 100, 200), SkColorSetRGB(10, 10, 10));
   canvas.FillRect(gfx::Rect(100, 0, 100, 200), SkColorSetRGB(100, 100, 100));
   canvas.FillRect(gfx::Rect(200, 0, 100, 200), SkColorSetRGB(255, 255, 255));
-  SkBitmap source = canvas.ToBitmap();
+  SkBitmap source = canvas.GetBitmap();
   SkBitmap result;
   result.allocPixels(SkImageInfo::MakeA8(300, 200));
 
   // This computation should fail since all colors always vary together.
   EXPECT_TRUE(ComputePrincipalComponentImage(source, &result));
 
   uint8_t min_gl = 0;
   uint8_t max_gl = 0;
   Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
 
@@ skipping 12 matching lines @@
                         {LumaRange::NORMAL, SaturationRange::VIBRANT},
                         {LumaRange::LIGHT, SaturationRange::VIBRANT},
                         {LumaRange::DARK, SaturationRange::MUTED},
                         {LumaRange::NORMAL, SaturationRange::MUTED},
                         {LumaRange::LIGHT, SaturationRange::MUTED}};
 
   // A totally dark gray image, which yields no prominent color as it's too
   // close to black.
   gfx::Canvas canvas(gfx::Size(300, 200), 1.0f, true);
   canvas.FillRect(gfx::Rect(0, 0, 300, 200), SkColorSetRGB(10, 10, 10));
-  SkBitmap bitmap = canvas.ToBitmap();
+  SkBitmap bitmap = canvas.GetBitmap();
 
   // All expectations start at SK_ColorTRANSPARENT (i.e. 0).
   SkColor expectations[arraysize(color_profiles)] = {};
   for (size_t i = 0; i < arraysize(color_profiles); ++i) {
     EXPECT_EQ(expectations[i],
               CalculateProminentColorOfBitmap(bitmap, color_profiles[i].luma,
                                               color_profiles[i].saturation));
   }
 
   // Add a green that could hit a couple values.
   const SkColor kVibrantGreen = SkColorSetRGB(25, 200, 25);
   canvas.FillRect(gfx::Rect(0, 1, 300, 1), kVibrantGreen);
-  bitmap = canvas.ToBitmap();
+  bitmap = canvas.GetBitmap();
   expectations[0] = kVibrantGreen;
   expectations[1] = kVibrantGreen;
   for (size_t i = 0; i < arraysize(color_profiles); ++i) {
     EXPECT_EQ(expectations[i],
               CalculateProminentColorOfBitmap(bitmap, color_profiles[i].luma,
                                               color_profiles[i].saturation));
   }
 
   // Add a stripe of a dark, muted green (saturation .33, luma .29).
   const SkColor kDarkGreen = SkColorSetRGB(50, 100, 50);
   canvas.FillRect(gfx::Rect(0, 2, 300, 1), kDarkGreen);
-  bitmap = canvas.ToBitmap();
+  bitmap = canvas.GetBitmap();
   expectations[3] = kDarkGreen;
   for (size_t i = 0; i < arraysize(color_profiles); ++i) {
     EXPECT_EQ(expectations[i],
               CalculateProminentColorOfBitmap(bitmap, color_profiles[i].luma,
                                               color_profiles[i].saturation));
   }
 
   // Now draw a little bit of pure green. That should be closer to the goal for
   // normal vibrant, but is out of range for other color profiles.
   const SkColor kPureGreen = SkColorSetRGB(0, 255, 0);
   canvas.FillRect(gfx::Rect(0, 3, 300, 1), kPureGreen);
-  bitmap = canvas.ToBitmap();
+  bitmap = canvas.GetBitmap();
   expectations[1] = kPureGreen;
   for (size_t i = 0; i < arraysize(color_profiles); ++i) {
     EXPECT_EQ(expectations[i],
               CalculateProminentColorOfBitmap(bitmap, color_profiles[i].luma,
                                               color_profiles[i].saturation));
   }
 }
 
 }  // namespace color_utils