hide SkBitmap::setConfig

patch from issue 325733002

TBR=scroggo

Author: reed@chromium.org

Review URL: https://codereview.chromium.org/322963002

15 files changed, 103 insertions, 138 deletions

diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index 2b0cabfc37..e877bd472d 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -1,10 +1,10 @@
-
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
+
 #include "SkBenchmark.h"
 #include "SkBitmap.h"
 #include "SkPaint.h"
@@ -12,10 +12,7 @@
 #include "SkColorPriv.h"
 #include "SkRandom.h"
 #include "SkString.h"
-
-static const char* gConfigName[] = {
-    "ERROR", "a1", "a8", "index8", "565", "4444", "8888"
-};
+#include "sk_tool_utils.h"
 
 static int conv6ToByte(int x) {
     return x * 0xFF / 5;
@@ -33,7 +30,7 @@ static uint8_t compute666Index(SkPMColor c) {
     return convByteTo6(r) * 36 + convByteTo6(g) * 6 + convByteTo6(b);
 }
 
-static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, bool isOpaque) {
+static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, SkAlphaType aType) {
     SkPMColor storage[216];
     SkPMColor* colors = storage;
     // rrr ggg bbb
@@ -47,10 +44,9 @@ static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, bool isOpaque)
             }
         }
     }
-    SkColorTable* ctable = new SkColorTable(storage, 216,
-                         isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
-    dst->setConfig(SkBitmap::kIndex8_Config, src.width(), src.height());
-    dst->allocPixels(ctable);
+    SkColorTable* ctable = new SkColorTable(storage, 216, aType);
+    dst->allocPixels(SkImageInfo::Make(src.width(), src.height(), kIndex_8_SkColorType, aType),
+                     NULL, ctable);
     ctable->unref();
 
     SkAutoLockPixels alps(src);
@@ -75,29 +71,30 @@ static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, bool isOpaque)
  */
 
 class BitmapBench : public SkBenchmark {
-    SkBitmap    fBitmap;
-    SkPaint     fPaint;
-    bool        fIsOpaque;
-    bool        fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
-    bool        fIsVolatile;
-    SkBitmap::Config fConfig;
-    SkString    fName;
+    const SkColorType   fColorType;
+    const SkAlphaType   fAlphaType;
+    const bool          fForceUpdate; //bitmap marked as dirty before each draw. forces bitmap to be updated on device cache
+    const bool          fIsVolatile;
+
+    SkBitmap            fBitmap;
+    SkPaint             fPaint;
+    SkString            fName;
+
     enum { W = 128 };
     enum { H = 128 };
 public:
-    BitmapBench(bool isOpaque, SkBitmap::Config c,
-                bool forceUpdate = false, bool bitmapVolatile = false)
-        : fIsOpaque(isOpaque)
+    BitmapBench(SkColorType ct, SkAlphaType at, bool forceUpdate = false, bool isVolatile = false)
+        : fColorType(ct)
+        , fAlphaType(at)
         , fForceUpdate(forceUpdate)
-        , fIsVolatile(bitmapVolatile)
-        , fConfig(c) {
-    }
+        , fIsVolatile(isVolatile)
+    {}
 
 protected:
     virtual const char* onGetName() {
         fName.set("bitmap");
-        fName.appendf("_%s%s", gConfigName[fConfig],
-                      fIsOpaque ? "" : "_A");
+        fName.appendf("_%s%s", sk_tool_utils::colortype_name(fColorType),
+                      kOpaque_SkAlphaType == fAlphaType ? "" : "_A");
         if (fForceUpdate)
             fName.append("_update");
         if (fIsVolatile)
@@ -109,24 +106,23 @@ protected:
     virtual void onPreDraw() {
         SkBitmap bm;
 
-        if (SkBitmap::kIndex8_Config == fConfig) {
-            bm.setConfig(SkBitmap::kARGB_8888_Config, W, H);
+        if (kIndex_8_SkColorType == fColorType) {
+            bm.setInfo(SkImageInfo::MakeN32(W, H, fAlphaType));
         } else {
-            bm.setConfig(fConfig, W, H);
+            bm.setInfo(SkImageInfo::Make(W, H, fColorType, fAlphaType));
         }
 
         bm.allocPixels();
-        bm.eraseColor(fIsOpaque ? SK_ColorBLACK : 0);
+        bm.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorBLACK : 0);
 
         onDrawIntoBitmap(bm);
 
-        if (SkBitmap::kIndex8_Config == fConfig) {
-            convertToIndex666(bm, &fBitmap, fIsOpaque);
+        if (kIndex_8_SkColorType == fColorType) {
+            convertToIndex666(bm, &fBitmap, fAlphaType);
         } else {
             fBitmap = bm;
         }
 
-        fBitmap.setAlphaType(fIsOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
         fBitmap.setIsVolatile(fIsVolatile);
     }
 
@@ -197,9 +193,9 @@ class FilterBitmapBench : public BitmapBench {
     uint32_t    fFlags;
     SkString    fFullName;
 public:
-    FilterBitmapBench(bool isOpaque, SkBitmap::Config c,
+    FilterBitmapBench(SkColorType ct, SkAlphaType at,
                       bool forceUpdate, bool isVolitile, uint32_t flags)
-        : INHERITED(isOpaque, c, forceUpdate, isVolitile)
+        : INHERITED(ct, at, forceUpdate, isVolitile)
         , fFlags(flags) {
     }
 
@@ -276,9 +272,9 @@ private:
     SkString    fFullName;
     SourceAlpha fSourceAlpha;
 public:
-    SourceAlphaBitmapBench(SourceAlpha alpha, SkBitmap::Config c,
+    SourceAlphaBitmapBench(SourceAlpha alpha, SkColorType ct,
                 bool forceUpdate = false, bool bitmapVolatile = false)
-        : INHERITED(false, c, forceUpdate, bitmapVolatile)
+        : INHERITED(ct, kPremul_SkAlphaType, forceUpdate, bitmapVolatile)
         , fSourceAlpha(alpha) {
     }
 
@@ -355,31 +351,31 @@ private:
     typedef BitmapBench INHERITED;
 };
 
-DEF_BENCH( return new BitmapBench(false, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kRGB_565_Config); )
-DEF_BENCH( return new BitmapBench(false, SkBitmap::kIndex8_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kIndex8_Config); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config, true, true); )
-DEF_BENCH( return new BitmapBench(true, SkBitmap::kARGB_8888_Config, true, false); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kPremul_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kRGB_565_SkColorType, kOpaque_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kPremul_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kIndex_8_SkColorType, kOpaque_SkAlphaType); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true); )
+DEF_BENCH( return new BitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false); )
 
 // scale filter -> S32_opaque_D32_filter_DX_{SSE2,SSSE3} and Fact9 is also for S32_D16_filter_DX_SSE2
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true, kScale_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false, kScale_Flag | kBilerp_Flag); )
 
 // scale rotate filter -> S32_opaque_D32_filter_DXDY_{SSE2,SSSE3}
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
-DEF_BENCH( return new FilterBitmapBench(true, SkBitmap::kARGB_8888_Config, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, true, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kOpaque_SkAlphaType, true, false, kScale_Flag | kRotate_Flag | kBilerp_Flag); )
 
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
-DEF_BENCH( return new FilterBitmapBench(false, SkBitmap::kARGB_8888_Config, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kBilerp_Flag | kBicubic_Flag); )
+DEF_BENCH( return new FilterBitmapBench(kN32_SkColorType, kPremul_SkAlphaType, false, false, kScale_Flag | kRotate_Flag | kBilerp_Flag | kBicubic_Flag); )
 
 // source alpha tests -> S32A_Opaque_BlitRow32_{arm,neon}
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kOpaque_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTransparent_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
-DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, SkBitmap::kARGB_8888_Config); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kOpaque_SourceAlpha, kN32_SkColorType); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTransparent_SourceAlpha, kN32_SkColorType); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kTwoStripes_SourceAlpha, kN32_SkColorType); )
+DEF_BENCH( return new SourceAlphaBitmapBench(SourceAlphaBitmapBench::kThreeStripes_SourceAlpha, kN32_SkColorType); )
diff --git a/bench/BitmapRectBench.cpp b/bench/BitmapRectBench.cpp
index affed723d9..32589fc38d 100644
--- a/bench/BitmapRectBench.cpp
+++ b/bench/BitmapRectBench.cpp
@@ -55,7 +55,7 @@ public:
         fFilterLevel = filterLevel;
         fSlightMatrix = slightMatrix;
 
-        fBitmap.setConfig(SkBitmap::kARGB_8888_Config, kWidth, kHeight);
+        fBitmap.setInfo(SkImageInfo::MakeN32Premul(kWidth, kHeight));
     }
 
 protected:
diff --git a/bench/BitmapScaleBench.cpp b/bench/BitmapScaleBench.cpp
index f6c2da17a9..93e10fa43c 100644
--- a/bench/BitmapScaleBench.cpp
+++ b/bench/BitmapScaleBench.cpp
@@ -57,14 +57,10 @@ protected:
     }
 
     virtual void onPreDraw() {
-        fInputBitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                               fInputSize, fInputSize, 0, kOpaque_SkAlphaType);
-        fInputBitmap.allocPixels();
+        fInputBitmap.allocN32Pixels(fInputSize, fInputSize, true);
         fInputBitmap.eraseColor(SK_ColorWHITE);
 
-        fOutputBitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                                fOutputSize, fOutputSize, 0, kOpaque_SkAlphaType);
-        fOutputBitmap.allocPixels();
+        fOutputBitmap.allocN32Pixels(fOutputSize, fOutputSize, true);
 
         fMatrix.setScale( scale(), scale() );
     }
diff --git a/bench/BlurImageFilterBench.cpp b/bench/BlurImageFilterBench.cpp
index bd36b5b3c4..7739730a77 100644
--- a/bench/BlurImageFilterBench.cpp
+++ b/bench/BlurImageFilterBench.cpp
@@ -55,10 +55,8 @@ private:
     void make_checkerboard() {
         const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
         const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
-        fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
-        fCheckerboard.allocPixels();
-        SkBitmapDevice device(fCheckerboard);
-        SkCanvas canvas(&device);
+        fCheckerboard.allocN32Pixels(w, h);
+        SkCanvas canvas(fCheckerboard);
         canvas.clear(0x00000000);
         SkPaint darkPaint;
         darkPaint.setColor(0xFF804020);
diff --git a/bench/CoverageBench.cpp b/bench/CoverageBench.cpp
index 2c84102f7d..0631c179ac 100644
--- a/bench/CoverageBench.cpp
+++ b/bench/CoverageBench.cpp
@@ -32,8 +32,7 @@ public:
         fPath.quadTo(500, 0, 500, 500);
         fPath.quadTo(250, 0, 0, 500);
 
-        fBitmap.setConfig(SkBitmap::kA8_Config, 500, 500);
-        fBitmap.allocPixels();
+        fBitmap.allocPixels(SkImageInfo::MakeA8(500, 500));
 
         fIdentity.setIdentity();
         fRC.setRect(fPath.getBounds().round());
diff --git a/bench/DisplacementBench.cpp b/bench/DisplacementBench.cpp
index 08da9b19af..904f47d842 100644
--- a/bench/DisplacementBench.cpp
+++ b/bench/DisplacementBench.cpp
@@ -33,10 +33,8 @@ protected:
     void makeBitmap() {
         const int w = this->isSmall() ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
         const int h = this->isSmall() ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
-        fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h);
-        fBitmap.allocPixels();
-        SkBitmapDevice device(fBitmap);
-        SkCanvas canvas(&device);
+        fBitmap.allocN32Pixels(w, h);
+        SkCanvas canvas(fBitmap);
         canvas.clear(0x00000000);
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -49,10 +47,8 @@ protected:
     void makeCheckerboard() {
         const int w = this->isSmall() ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
         const int h = this->isSmall() ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
-        fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
-        fCheckerboard.allocPixels();
-        SkBitmapDevice device(fCheckerboard);
-        SkCanvas canvas(&device);
+        fCheckerboard.allocN32Pixels(w, h);
+        SkCanvas canvas(fCheckerboard);
         canvas.clear(0x00000000);
         SkPaint darkPaint;
         darkPaint.setColor(0xFF804020);
diff --git a/bench/GameBench.cpp b/bench/GameBench.cpp
index c0a0e1b1b3..d197f3e170 100644
--- a/bench/GameBench.cpp
+++ b/bench/GameBench.cpp
@@ -248,9 +248,7 @@ private:
     void makeCheckerboard() {
         static int kCheckSize = 16;
 
-        fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config,
-                                kCheckerboardWidth, kCheckerboardHeight);
-        fCheckerboard.allocPixels();
+        fCheckerboard.allocN32Pixels(kCheckerboardWidth, kCheckerboardHeight);
         SkAutoLockPixels lock(fCheckerboard);
         for (int y = 0; y < kCheckerboardHeight; ++y) {
             int even = (y / kCheckSize) % 2;
@@ -283,8 +281,7 @@ private:
             }
         }
 
-        fAtlas.setConfig(SkBitmap::kARGB_8888_Config, kTotAtlasWidth, kTotAtlasHeight);
-        fAtlas.allocPixels();
+        fAtlas.allocN32Pixels(kTotAtlasWidth, kTotAtlasHeight);
         SkAutoLockPixels lock(fAtlas);
 
         for (int y = 0; y < kTotAtlasHeight; ++y) {
diff --git a/bench/ImageCacheBench.cpp b/bench/ImageCacheBench.cpp
index 9fc538ebef..ef29cf88ff 100644
--- a/bench/ImageCacheBench.cpp
+++ b/bench/ImageCacheBench.cpp
@@ -18,16 +18,14 @@ class ImageCacheBench : public SkBenchmark {
     };
 public:
     ImageCacheBench()  : fCache(CACHE_COUNT * 100) {
-        fBM.setConfig(SkBitmap::kARGB_8888_Config, DIM, DIM);
-        fBM.allocPixels();
+        fBM.allocN32Pixels(DIM, DIM);
     }
 
     void populateCache() {
         SkScalar scale = 1;
         for (int i = 0; i < CACHE_COUNT; ++i) {
             SkBitmap tmp;
-            tmp.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
-            tmp.allocPixels();
+            tmp.allocN32Pixels(1, 1);
             fCache.unlock(fCache.addAndLock(fBM, scale, scale, tmp));
             scale += 1;
         }
diff --git a/bench/MagnifierBench.cpp b/bench/MagnifierBench.cpp
index 3ef2062c4e..e4a51815d4 100644
--- a/bench/MagnifierBench.cpp
+++ b/bench/MagnifierBench.cpp
@@ -53,10 +53,8 @@ private:
     void make_checkerboard() {
         const int w = fIsSmall ? FILTER_WIDTH_SMALL : FILTER_WIDTH_LARGE;
         const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
-        fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
-        fCheckerboard.allocPixels();
-        SkBitmapDevice device(fCheckerboard);
-        SkCanvas canvas(&device);
+        fCheckerboard.allocN32Pixels(w, h);
+        SkCanvas canvas(fCheckerboard);
         canvas.clear(0x00000000);
         SkPaint darkPaint;
         darkPaint.setColor(0xFF804020);
diff --git a/bench/MergeBench.cpp b/bench/MergeBench.cpp
index cec0ea93e4..9f16449a82 100644
--- a/bench/MergeBench.cpp
+++ b/bench/MergeBench.cpp
@@ -52,10 +52,8 @@ private:
     }
 
     void make_bitmap() {
-        fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
-        fBitmap.allocPixels();
-        SkBitmapDevice device(fBitmap);
-        SkCanvas canvas(&device);
+        fBitmap.allocN32Pixels(80, 80);
+        SkCanvas canvas(fBitmap);
         canvas.clear(0x00000000);
         SkPaint paint;
         paint.setAntiAlias(true);
@@ -66,10 +64,8 @@ private:
     }
 
     void make_checkerboard() {
-        fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
-        fCheckerboard.allocPixels();
-        SkBitmapDevice device(fCheckerboard);
-        SkCanvas canvas(&device);
+        fCheckerboard.allocN32Pixels(80, 80);
+        SkCanvas canvas(fCheckerboard);
         canvas.clear(0x00000000);
         SkPaint darkPaint;
         darkPaint.setColor(0xFF804020);
diff --git a/bench/PictureRecordBench.cpp b/bench/PictureRecordBench.cpp
index 0666cc4211..f890e0d4f6 100644
--- a/bench/PictureRecordBench.cpp
+++ b/bench/PictureRecordBench.cpp
@@ -85,8 +85,8 @@ protected:
 
             // create a simple bitmap
             SkBitmap bitmap;
-            bitmap.setConfig(SkBitmap::kRGB_565_Config, 10, 10);
-            bitmap.allocPixels();
+            bitmap.allocPixels(SkImageInfo::Make(10, 10,
+                                                 kRGB_565_SkColorType, kOpaque_SkAlphaType));
 
             // draw a single color into the bitmap
             SkCanvas bitmapCanvas(bitmap);
diff --git a/bench/ReadPixBench.cpp b/bench/ReadPixBench.cpp
index f761e3306c..805aaeb5f8 100644
--- a/bench/ReadPixBench.cpp
+++ b/bench/ReadPixBench.cpp
@@ -43,7 +43,7 @@ protected:
 
         SkBitmap bitmap;
 
-        bitmap.setConfig(SkBitmap::kARGB_8888_Config, kWindowSize, kWindowSize);
+        bitmap.setInfo(SkImageInfo::MakeN32Premul(kWindowSize, kWindowSize));
 
         for (int i = 0; i < loops; i++) {
             for (int x = 0; x < kNumStepsX; ++x) {
diff --git a/bench/RectBench.cpp b/bench/RectBench.cpp
index 901304442f..a2029e601f 100644
--- a/bench/RectBench.cpp
+++ b/bench/RectBench.cpp
@@ -263,8 +263,7 @@ protected:
         paint.setStrokeCap(SkPaint::kRound_Cap);
         if (_type == KMaskShader) {
             SkBitmap srcBM;
-            srcBM.setConfig(SkBitmap::kARGB_8888_Config, 10, 1);
-            srcBM.allocPixels();
+            srcBM.allocN32Pixels(10, 1);
             srcBM.eraseColor(0xFF00FF00);
 
             SkShader* s;
diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp
index fcbffb2a10..0e33ec0281 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp
@@ -12,10 +12,7 @@
 #include "SkPaint.h"
 #include "SkShader.h"
 #include "SkString.h"
-
-static const char* gConfigName[] = {
-    "ERROR", "a1", "a8", "index8", "565", "4444", "8888"
-};
+#include "sk_tool_utils.h"
 
 static void draw_into_bitmap(const SkBitmap& bm) {
     const int w = bm.width();
@@ -52,8 +49,7 @@ static uint8_t compute_666_index(SkPMColor c) {
     return conv_byte_to_6(r) * 36 + conv_byte_to_6(g) * 6 + conv_byte_to_6(b);
 }
 
-static void convert_to_index666(const SkBitmap& src, SkBitmap* dst,
-                                bool isOpaque) {
+static void convert_to_index666(const SkBitmap& src, SkBitmap* dst) {
     SkPMColor storage[216];
     SkPMColor* colors = storage;
     // rrr ggg bbb
@@ -67,10 +63,10 @@ static void convert_to_index666(const SkBitmap& src, SkBitmap* dst,
             }
         }
     }
-    SkAlphaType aType = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-    SkColorTable* ctable = new SkColorTable(storage, 216, aType);
-    dst->setConfig(SkBitmap::kIndex8_Config, src.width(), src.height());
-    dst->allocPixels(ctable);
+    SkColorTable* ctable = new SkColorTable(storage, 216, kOpaque_SkAlphaType);
+    dst->allocPixels(SkImageInfo::Make(src.width(), src.height(),
+                                       kIndex_8_SkColorType, kOpaque_SkAlphaType),
+                     NULL, ctable);
     ctable->unref();
 
     SkAutoLockPixels alps(src);
@@ -86,25 +82,25 @@ static void convert_to_index666(const SkBitmap& src, SkBitmap* dst,
 }
 
 class RepeatTileBench : public SkBenchmark {
-    SkPaint          fPaint;
-    SkString         fName;
-    SkBitmap         fBitmap;
-    bool             fIsOpaque;
-    SkBitmap::Config fConfig;
+    const SkColorType   fColorType;
+    const SkAlphaType   fAlphaType;
+    SkPaint             fPaint;
+    SkString            fName;
+    SkBitmap            fBitmap;
 public:
-    RepeatTileBench(SkBitmap::Config c, bool isOpaque = false)  {
+    RepeatTileBench(SkColorType ct, SkAlphaType at = kPremul_SkAlphaType)
+        : fColorType(ct), fAlphaType(at)
+    {
         const int w = 50;
         const int h = 50;
-        fConfig = c;
-        fIsOpaque = isOpaque;
 
-        if (SkBitmap::kIndex8_Config == fConfig) {
-            fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h);
+        if (kIndex_8_SkColorType == ct) {
+            fBitmap.setInfo(SkImageInfo::MakeN32(w, h, at));
         } else {
-            fBitmap.setConfig(fConfig, w, h);
+            fBitmap.setInfo(SkImageInfo::Make(w, h, ct, at));
         }
         fName.printf("repeatTile_%s_%c",
-                     gConfigName[fBitmap.config()], isOpaque ? 'X' : 'A');
+                     sk_tool_utils::colortype_name(ct), kOpaque_SkAlphaType == at ? 'X' : 'A');
     }
 
 protected:
@@ -114,15 +110,13 @@ protected:
 
     virtual void onPreDraw() SK_OVERRIDE {
         fBitmap.allocPixels();
-        fBitmap.eraseColor(fIsOpaque ? SK_ColorWHITE : 0);
-        fBitmap.setAlphaType(fIsOpaque ?
-                             kOpaque_SkAlphaType : kPremul_SkAlphaType);
+        fBitmap.eraseColor(kOpaque_SkAlphaType == fAlphaType ? SK_ColorWHITE : 0);
 
         draw_into_bitmap(fBitmap);
 
-        if (SkBitmap::kIndex8_Config == fConfig) {
+        if (kIndex_8_SkColorType == fColorType) {
             SkBitmap tmp;
-            convert_to_index666(fBitmap, &tmp, fIsOpaque);
+            convert_to_index666(fBitmap, &tmp);
             fBitmap = tmp;
         }
 
@@ -146,7 +140,7 @@ private:
     typedef SkBenchmark INHERITED;
 };
 
-DEF_BENCH(return new RepeatTileBench(SkBitmap::kARGB_8888_Config, true))
-DEF_BENCH(return new RepeatTileBench(SkBitmap::kARGB_8888_Config, false))
-DEF_BENCH(return new RepeatTileBench(SkBitmap::kRGB_565_Config))
-DEF_BENCH(return new RepeatTileBench(SkBitmap::kIndex8_Config))
+DEF_BENCH(return new RepeatTileBench(kN32_SkColorType, kOpaque_SkAlphaType))
+DEF_BENCH(return new RepeatTileBench(kN32_SkColorType, kPremul_SkAlphaType))
+DEF_BENCH(return new RepeatTileBench(kRGB_565_SkColorType, kOpaque_SkAlphaType))
+DEF_BENCH(return new RepeatTileBench(kIndex_8_SkColorType, kPremul_SkAlphaType))
diff --git a/bench/TileBench.cpp b/bench/TileBench.cpp
index 9a9e27e951..12c9629ee2 100644
--- a/bench/TileBench.cpp
+++ b/bench/TileBench.cpp
@@ -48,9 +48,7 @@ public:
         , fDoScale(doScale) {
         SkBitmap bm;
 
-        bm.setConfig(SkBitmap::kARGB_8888_Config, kWidth, kHeight, 0,
-                     kOpaque_SkAlphaType);
-        bm.allocPixels();
+        bm.allocN32Pixels(kWidth, kHeight, true);
         bm.eraseColor(SK_ColorWHITE);
 
         create_gradient(&bm);