remove deprecated use of bitmap config from tests

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 SkColorType enum
-static const char* gConfigName[] = {
-    "Unknown", "Alpha8", "565", "4444", "RGBA", "BGRA", "Index8"
+static const char* gColorTypeName[] = {
+    "None", "A8", "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 27 matching lines @@
     return -1;
 }
 
 static int proc_bad(const void*, int, uint32_t, uint32_t* bad) {
     *bad = 0;
     return 0;
 }
 
 static Proc find_proc(const SkBitmap& bm, SkPMColor expect32, uint16_t expect16,
                       uint8_t expect8, uint32_t* expect) {
-    switch (bm.config()) {
-        case SkBitmap::kARGB_8888_Config:
+    switch (bm.colorType()) {
+        case kPMColor_SkColorType:
             *expect = expect32;
             return proc_32;
-        case SkBitmap::kARGB_4444_Config:
-        case SkBitmap::kRGB_565_Config:
+        case kARGB_4444_SkColorType:
+        case kRGB_565_SkColorType:
             *expect = expect16;
             return proc_16;
-        case SkBitmap::kA8_Config:
+        case kAlpha_8_SkColorType:
             *expect = expect8;
             return proc_8;
         default:
             *expect = 0;
             return proc_bad;
     }
 }
 
 static bool check_color(const SkBitmap& bm, SkPMColor expect32,
                         uint16_t expect16, uint8_t expect8,
                         skiatest::Reporter* reporter) {
     uint32_t expect;
     Proc proc = find_proc(bm, expect32, expect16, expect8, &expect);
     for (int y = 0; y < bm.height(); y++) {
         uint32_t bad;
         int x = proc(bm.getAddr(0, y), bm.width(), expect, &bad);
         if (x >= 0) {
-            ERRORF(reporter, "BlitRow config=%s [%d %d] expected %x got %x",
-                   gConfigName[bm.config()], x, y, expect, bad);
+            ERRORF(reporter, "BlitRow colortype=%s [%d %d] expected %x got %x",
+                   gColorTypeName[bm.colorType()], x, y, expect, bad);
             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;
 
@@ skipping 139 matching lines @@
 
                     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 colortype=%s bg=0x%x dither=%d"
                                " alpha=0x%x src=0x%x",
-                               gConfigName[gDstColorType[i]], bgColor, dither,
+                               gColorTypeName[gDstColorType[i]], bgColor, dither,
                                alpha, c);
                     }
                 }
             }
         }
     }
 }
 
 DEF_TEST(BlitRow, reporter) {
     test_00_FF(reporter);
     test_diagonal(reporter);
 }