replace setConfig+allocPixels with alloc-or-install-pixels

tests/BlitRowTest.cpp

 /*
  * 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 "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkGradientShader.h"
 #include "SkRect.h"
 #include "Test.h"
 
-// these are in the same order as the SkBitmap::Config enum
+// these are in the same order as the SkColorType enum
 static const char* gConfigName[] = {
-    "None", "A8", "Index8", "565", "4444", "8888"
+    "Unknown", "Alpha8", "565", "4444", "RGBA", "BGRA", "Index8"
 };
 
 /** Returns -1 on success, else the x coord of the first bad pixel, return its
     value in bad
  */
 typedef int (*Proc)(const void*, int width, uint32_t expected, uint32_t* bad);
 
 static int proc_32(const void* ptr, int w, uint32_t expected, uint32_t* bad) {
     const SkPMColor* addr = static_cast<const SkPMColor*>(ptr);
     for (int x = 0; x < w; x++) {
@@ skipping 65 matching lines @@
             return false;
         }
     }
     return true;
 }
 
 // Make sure our blits always map src==0 to a noop, and src==FF to full opaque
 static void test_00_FF(skiatest::Reporter* reporter) {
     static const int W = 256;
 
-    static const SkBitmap::Config gDstConfig[] = {
-        SkBitmap::kARGB_8888_Config,
-        SkBitmap::kRGB_565_Config,
-//        SkBitmap::kARGB_4444_Config,
-//        SkBitmap::kA8_Config,
+    static const SkColorType gDstColorType[] = {
+        kPMColor_SkColorType,
+        kRGB_565_SkColorType,
     };
 
     static const struct {
         SkColor     fSrc;
         SkColor     fDst;
         SkPMColor   fResult32;
         uint16_t    fResult16;
         uint8_t     fResult8;
     } gSrcRec[] = {
         { 0,            0,          0,                                    0,      0 },
         { 0,            0xFFFFFFFF, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF },
         { 0xFFFFFFFF,   0,          SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF },
         { 0xFFFFFFFF,   0xFFFFFFFF, SkPackARGB32(0xFF, 0xFF, 0xFF, 0xFF), 0xFFFF, 0xFF },
     };
 
     SkPaint paint;
 
     SkBitmap srcBM;
-    srcBM.setConfig(SkBitmap::kARGB_8888_Config, W, 1);
-    srcBM.allocPixels();
+    srcBM.allocN32Pixels(W, 1);
 
-    for (size_t i = 0; i < SK_ARRAY_COUNT(gDstConfig); i++) {
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gDstColorType); i++) {
+        SkImageInfo info = SkImageInfo::Make(W, 1, gDstColorType[i],
+                                             kPremul_SkAlphaType);
         SkBitmap dstBM;
-        dstBM.setConfig(gDstConfig[i], W, 1);
-        dstBM.allocPixels();
+        dstBM.allocPixels(info);
 
         SkCanvas canvas(dstBM);
         for (size_t j = 0; j < SK_ARRAY_COUNT(gSrcRec); j++) {
             srcBM.eraseColor(gSrcRec[j].fSrc);
             dstBM.eraseColor(gSrcRec[j].fDst);
 
             for (int k = 0; k < 4; k++) {
                 bool dither = (k & 1) != 0;
                 bool blend = (k & 2) != 0;
                 if (gSrcRec[j].fSrc != 0 && blend) {
@@ skipping 43 matching lines @@
 }
 
 static bool gOnce;
 
 // Make sure our blits are invariant with the width of the blit (i.e. that
 // special case for 8 at a time have the same results as narrower blits)
 static void test_diagonal(skiatest::Reporter* reporter) {
     static const int W = 64;
     static const int H = W;
 
-    static const SkBitmap::Config gDstConfig[] = {
-        SkBitmap::kARGB_8888_Config,
-        SkBitmap::kRGB_565_Config,
-        //        SkBitmap::kARGB_4444_Config,
-        //        SkBitmap::kA8_Config,
+    static const SkColorType gDstColorType[] = {
+        kPMColor_SkColorType,
+        kRGB_565_SkColorType,
     };
 
     static const SkColor gDstBG[] = { 0, 0xFFFFFFFF };
 
     SkPaint paint;
 
     SkBitmap srcBM;
-    srcBM.setConfig(SkBitmap::kARGB_8888_Config, W, H);
-    srcBM.allocPixels();
+    srcBM.allocN32Pixels(W, H);
     SkRect srcR = {
         0, 0, SkIntToScalar(srcBM.width()), SkIntToScalar(srcBM.height()) };
 
     // cons up a mesh to draw the bitmap with
     Mesh mesh(srcBM, &paint);
 
-    for (size_t i = 0; i < SK_ARRAY_COUNT(gDstConfig); i++) {
+    SkImageInfo info = SkImageInfo::Make(W, H, kUnknown_SkColorType,
+                                         kPremul_SkAlphaType);
+
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gDstColorType); i++) {
+        info.fColorType = gDstColorType[i];
+
         SkBitmap dstBM0, dstBM1;
-        dstBM0.setConfig(gDstConfig[i], W, H);
-        dstBM1.setConfig(gDstConfig[i], W, H);
-        dstBM0.allocPixels();
-        dstBM1.allocPixels();
+        dstBM0.allocPixels(info);
+        dstBM1.allocPixels(info);
 
         SkCanvas canvas0(dstBM0);
         SkCanvas canvas1(dstBM1);
         SkColor bgColor;
 
         for (size_t j = 0; j < SK_ARRAY_COUNT(gDstBG); j++) {
             bgColor = gDstBG[j];
 
             for (int c = 0; c <= 0xFF; c++) {
                 srcBM.eraseARGB(0xFF, c, c, c);
@@ skipping 10 matching lines @@
                     canvas0.drawRect(srcR, paint);
                     mesh.draw(&canvas1, &paint);
 
                     if (!gOnce && false) {
                         save_bm(dstBM0, "drawBitmap.png");
                         save_bm(dstBM1, "drawMesh.png");
                         gOnce = true;
                     }
 
                     if (memcmp(dstBM0.getPixels(), dstBM1.getPixels(), dstBM0.getSize())) {
-                        ERRORF(reporter, "Diagonal config=%s bg=0x%x dither=%d"
+                        ERRORF(reporter, "Diagonal colortype=%s bg=0x%x dither=%d"
                                " alpha=0x%x src=0x%x",
-                               gConfigName[gDstConfig[i]], bgColor, dither,
+                               gConfigName[gDstColorType[i]], bgColor, dither,
                                alpha, c);
                     }
                 }
             }
         }
     }
 }
 
 DEF_TEST(BlitRow, reporter) {
     test_00_FF(reporter);
     test_diagonal(reporter);
 }