Rename kPMColor_SkColorType to kN32_SkColorType.

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 250 matching lines @@
         }
     }
 
     /* 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) {
         SkColorType colorType = bitmap.colorType();
         switch (colorType) {
-        case kPMColor_SkColorType:
+        case kN32_SkColorType:
             force_all_opaque_8888(bitmap);
             break;
         case kRGB_565_SkColorType:
             // nothing to do here; 565 bitmaps are inherently opaque
             break;
         default:
             SkDebugf("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);
             }
         }
     }
 
     static ErrorCombination write_bitmap(const SkString& path, const SkBitmap& bitmap) {
         // TODO(epoger): Now that we have removed force_all_opaque()
         // from this method, we should be able to get rid of the
         // transformation to 8888 format also.
         SkBitmap copy;
-        bitmap.copyTo(&copy, kPMColor_SkColorType);
+        bitmap.copyTo(&copy, kN32_SkColorType);
         if (!SkImageEncoder::EncodeFile(path.c_str(), copy,
                                         SkImageEncoder::kPNG_Type,
                                         100)) {
             SkDebugf("FAILED to write bitmap: %s\n", path.c_str());
             return ErrorCombination(kWritingReferenceImage_ErrorType);
         }
         return kEmpty_ErrorCombination;
     }
 
     /**
@@ skipping 425 matching lines @@
         const int expectedWidth = expectedBitmap.width();
         const int expectedHeight = expectedBitmap.height();
         const int width = actualBitmap.width();
         const int height = actualBitmap.height();
         if ((expectedWidth != width) || (expectedHeight != height)) {
             SkDebugf("---- %s: dimension mismatch -- expected [%d %d], actual [%d %d]\n",
                      testName, expectedWidth, expectedHeight, width, height);
             return;
         }
 
-        if ((kPMColor_SkColorType != expectedBitmap.colorType()) ||
-            (kPMColor_SkColorType != actualBitmap.colorType())) {
+        if ((kN32_SkColorType != expectedBitmap.colorType()) ||
+            (kN32_SkColorType != actualBitmap.colorType())) {
             SkDebugf("---- %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 1686 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