replace SkBitmap::Config with SkColorType in gms

gm/gmmain.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.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 247 matching lines @@
             return make_filename(path, shortName, configName, renderModeDescriptor,
                                  kPNG_FileExtension);
         }
     }
 
     /* since PNG insists on unpremultiplying our alpha, we take no
        precision chances and force all pixels to be 100% opaque,
        otherwise on compare we may not get a perfect match.
     */
     static void force_all_opaque(const SkBitmap& bitmap) {
-        SkBitmap::Config config = bitmap.config();
-        switch (config) {
-        case SkBitmap::kARGB_8888_Config:
+        SkColorType colorType = bitmap.colorType();
+        switch (colorType) {
+        case kPMColor_SkColorType:
             force_all_opaque_8888(bitmap);
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             // nothing to do here; 565 bitmaps are inherently opaque
             break;
         default:
-            gm_fprintf(stderr, "unsupported bitmap config %d\n", config);
+            gm_fprintf(stderr, "unsupported bitmap colorType %d\n", colorType);
             DEBUGFAIL_SEE_STDERR;
         }
     }
 
     static void force_all_opaque_8888(const SkBitmap& bitmap) {
         SkAutoLockPixels lock(bitmap);
         for (int y = 0; y < bitmap.height(); y++) {
             for (int x = 0; x < bitmap.width(); x++) {
                 *bitmap.getAddr32(x, y) |= (SK_A32_MASK << SK_A32_SHIFT);
             }
@@ skipping 295 matching lines @@
             surface.reset(SkSurface::NewRenderTargetDirect(gpuTarget->asRenderTarget()));
             if (deferred) {
                 canvas.reset(SkDeferredCanvas::Create(surface));
             } else {
                 canvas.reset(SkRef(surface->getCanvas()));
             }
             invokeGM(gm, canvas, false, deferred);
             // the device is as large as the current rendertarget, so
             // we explicitly only readback the amount we expect (in
             // size) overwrite our previous allocation
-            bitmap->setConfig(SkBitmap::kARGB_8888_Config, size.fWidth,
-                              size.fHeight);
+            bitmap->setConfig(SkImageInfo::MakeN32Premul(size.fWidth, size.fHeight));
             canvas->readPixels(bitmap, 0, 0);
         }
 #endif
         complete_bitmap(bitmap);
         return kEmpty_ErrorCombination;
     }
 
     static void generate_image_from_picture(GM* gm, const ConfigData& gRec,
                                             SkPicture* pict, SkBitmap* bitmap,
                                             SkScalar scale = SK_Scalar1,
@@ skipping 129 matching lines @@
         const int expectedHeight = expectedBitmap.height();
         const int width = actualBitmap.width();
         const int height = actualBitmap.height();
         if ((expectedWidth != width) || (expectedHeight != height)) {
             gm_fprintf(stderr, "---- %s: dimension mismatch --"
                        " expected [%d %d], actual [%d %d]\n",
                        testName, expectedWidth, expectedHeight, width, height);
             return;
         }
 
-        if ((SkBitmap::kARGB_8888_Config != expectedBitmap.config()) ||
-            (SkBitmap::kARGB_8888_Config != actualBitmap.config())) {
+        if ((kPMColor_SkColorType != expectedBitmap.colorType()) ||
+            (kPMColor_SkColorType != actualBitmap.colorType())) {
             gm_fprintf(stderr, "---- %s: not computing max per-channel"
                        " pixel mismatch because non-8888\n", testName);
             return;
         }
 
         SkAutoLockPixels alp0(expectedBitmap);
         SkAutoLockPixels alp1(actualBitmap);
         int errR = 0;
         int errG = 0;
         int errB = 0;
@@ skipping 1663 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif