setConfig is deprecated, use setInfo or allocPixels instead

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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 76 matching lines @@
   0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82
 };
 
 const HSL kDefaultLowerBound = {-1, -1, 0.15};
 const HSL kDefaultUpperBound = {-1, -1, 0.85};
 
 // Creates a 1-dimensional png of the pixel colors found in |colors|.
 scoped_refptr<base::RefCountedMemory> CreateTestPNG(
     const std::vector<SkColor>& colors) {
   SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kARGB_8888_Config, colors.size(), 1);
-  bitmap.allocPixels();
+  bitmap.allocN32Pixels(colors.size(), 1);
 
   SkAutoLockPixels lock(bitmap);
   for (size_t i = 0; i < colors.size(); ++i) {
     bitmap.eraseArea(SkIRect::MakeXYWH(i, 0, 1, 1), colors[i]);
   }
   return gfx::Image::CreateFrom1xBitmap(bitmap).As1xPNGBytes();
 }
 
 class MockKMeanImageSampler : public KMeanImageSampler {
  public:
@@ skipping 163 matching lines @@
   EXPECT_EQ(4 + 10 * kWidth, sampler.GetSample(kWidth, kHeight));
 }
 
 TEST_F(ColorAnalysisTest, FindClosestColor) {
   // Empty image returns input color.
   SkColor color = FindClosestColor(NULL, 0, 0, SK_ColorRED);
   EXPECT_EQ(SK_ColorRED, color);
 
   // Single color image returns that color.
   SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
-  bitmap.allocPixels();
+  bitmap.allocN32Pixels(16, 16);
   bitmap.eraseColor(SK_ColorWHITE);
   color = FindClosestColor(static_cast<uint8_t*>(bitmap.getPixels()),
                            bitmap.width(),
                            bitmap.height(),
                            SK_ColorRED);
   EXPECT_EQ(SK_ColorWHITE, color);
 
   // Write a black pixel into the image. A dark grey input pixel should match
   // the black one in the image.
   uint32_t* pixel = bitmap.getAddr32(0, 0);
   *pixel = SK_ColorBLACK;
   color = FindClosestColor(static_cast<uint8_t*>(bitmap.getPixels()),
                            bitmap.width(),
                            bitmap.height(),
                            SK_ColorDKGRAY);
   EXPECT_EQ(SK_ColorBLACK, color);
 }
 
 TEST_F(ColorAnalysisTest, CalculateKMeanColorOfBitmap) {
   // Create a 16x16 bitmap to represent a favicon.
   SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
-  bitmap.allocPixels();
+  bitmap.allocN32Pixels(16, 16);
   bitmap.eraseARGB(255, 100, 150, 200);
 
   SkColor color = CalculateKMeanColorOfBitmap(bitmap);
   EXPECT_EQ(255u, SkColorGetA(color));
   // Color values are not exactly equal due to reversal of premultiplied alpha.
   EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
   EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
   EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
 
   // Test a bitmap with an alpha channel.
   bitmap.eraseARGB(128, 100, 150, 200);
   color = CalculateKMeanColorOfBitmap(bitmap);
 
   // Alpha channel should be ignored for dominant color calculation.
   EXPECT_EQ(255u, SkColorGetA(color));
   EXPECT_TRUE(ChannelApproximatelyEqual(100, SkColorGetR(color)));
   EXPECT_TRUE(ChannelApproximatelyEqual(150, SkColorGetG(color)));
   EXPECT_TRUE(ChannelApproximatelyEqual(200, SkColorGetB(color)));
 }
 
 TEST_F(ColorAnalysisTest, ComputeColorCovarianceTrivial) {
   SkBitmap bitmap;
-  bitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 200);
+  bitmap.setInfo(SkImageInfo::MakeN32Premul(100, 200));
 
   EXPECT_EQ(gfx::Matrix3F::Zeros(), ComputeColorCovariance(bitmap));
   bitmap.allocPixels();
   bitmap.eraseARGB(255, 50, 150, 200);
   gfx::Matrix3F covariance = ComputeColorCovariance(bitmap);
   // The answer should be all zeros.
   EXPECT_TRUE(covariance == gfx::Matrix3F::Zeros());
 }
 
 TEST_F(ColorAnalysisTest, ComputeColorCovarianceWithCanvas) {
@@ skipping 14 matching lines @@
   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
   // bound to be uninteresting. This is an important edge case, though.
   SkBitmap source, result;
-  source.setConfig(SkBitmap::kARGB_8888_Config, 300, 200);
-  result.setConfig(SkBitmap::kA8_Config, 300, 200);
+  source.allocN32Pixels(300, 200);
+  result.allocPixels(SkImageInfo::MakeA8(300, 200));
 
-  source.allocPixels();
-  result.allocPixels();
   source.eraseARGB(255, 50, 150, 200);
 
   gfx::Vector3dF transform(1.0f, .5f, 0.1f);
   // This transform, if not scaled, should result in GL=145.
   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(145, min_gl);
@@ skipping 24 matching lines @@
   // 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 =
       skia::GetTopDevice(*canvas.sk_canvas())->accessBitmap(false);
   SkBitmap result;
-  result.setConfig(SkBitmap::kA8_Config, 300, 200);
-  result.allocPixels();
+  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);
   EXPECT_EQ(255, max_gl);
   EXPECT_EQ(min_gl, SkColorGetA(result.getColor(0, 0)));
@@ skipping 17 matching lines @@
   // 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 =
       skia::GetTopDevice(*canvas.sk_canvas())->accessBitmap(false);
   SkBitmap result;
-  result.setConfig(SkBitmap::kA8_Config, 300, 200);
-  result.allocPixels();
+  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);
   EXPECT_EQ(min_gl, SkColorGetA(result.getColor(299, 199)));
   EXPECT_EQ(max_gl, SkColorGetA(result.getColor(150, 0)));
   EXPECT_EQ(100U, SkColorGetA(result.getColor(0, 0)));
 
   EXPECT_TRUE(ApplyColorReduction(source, transform, true, &result));
   Calculate8bitBitmapMinMax(result, &min_gl, &max_gl);
   EXPECT_EQ(0, min_gl);
   EXPECT_EQ(255, max_gl);
   EXPECT_EQ(min_gl, SkColorGetA(result.getColor(299, 199)));
   EXPECT_EQ(max_gl, SkColorGetA(result.getColor(150, 0)));
   EXPECT_EQ(193U, SkColorGetA(result.getColor(0, 0)));
 }
 
 TEST_F(ColorAnalysisTest, ComputePrincipalComponentImageNotComputable) {
   SkBitmap source, result;
-  source.setConfig(SkBitmap::kARGB_8888_Config, 300, 200);
-  result.setConfig(SkBitmap::kA8_Config, 300, 200);
+  source.allocN32Pixels(300, 200);
+  result.allocPixels(SkImageInfo::MakeA8(300, 200));
 
-  source.allocPixels();
-  result.allocPixels();
   source.eraseARGB(255, 50, 150, 200);
 
   // This computation should fail since all colors always vary together.
   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 =
       skia::GetTopDevice(*canvas.sk_canvas())->accessBitmap(false);
   SkBitmap result;
-  result.setConfig(SkBitmap::kA8_Config, 300, 200);
-  result.allocPixels();
+  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);
 
   EXPECT_EQ(0, min_gl);
   EXPECT_EQ(255, max_gl);
   EXPECT_EQ(min_gl, SkColorGetA(result.getColor(0, 0)));
   EXPECT_EQ(max_gl, SkColorGetA(result.getColor(299, 199)));
   EXPECT_EQ(93U, SkColorGetA(result.getColor(150, 0)));
 }
 
 }  // namespace color_utils