hide Config in SkImageDecoder -- use SkColorType instead

tools/skimage_main.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 "gm_expectations.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 99 matching lines @@
 static SkTArray<SkString, false> gSuccessfulSubsetDecodes;
 static SkTArray<SkString, false> gFailedSubsetDecodes;
 // Files/subsets that do not have expectations. Not reported as a failure of the test so
 // the bots will not turn red with each new image test.
 static SkTArray<SkString, false> gMissingExpectations;
 static SkTArray<SkString, false> gMissingSubsetExpectations;
 // For files that are expected to fail.
 static SkTArray<SkString, false> gKnownFailures;
 static SkTArray<SkString, false> gKnownSubsetFailures;
 
-static SkBitmap::Config gPrefConfig(SkBitmap::kNo_Config);
+static SkColorType gPrefColorType(kUnknown_SkColorType);
 
 // Expections read from a file specified by readExpectationsPath. The expectations must have been
 // previously written using createExpectationsPath.
 SkAutoTUnref<skiagm::JsonExpectationsSource> gJsonExpectations;
 
 /**
  *  Encode the bitmap to a file, written one of two ways, depending on
  *  FLAGS_writeChecksumBasedFilenames. If true, the final image will be
  *  written to:
  *      outDir/hashType/src/digestValue.png
@@ skipping 307 matching lines @@
         // An error was already reported.
         return;
     }
     SkASSERT(srcPath);
     SkASSERT(codec);
     FILEStreamWithoutLength stream(srcPath);
     // This will only be called after a successful decode. Creating a stream from the same
     // path should never fail.
     SkASSERT(stream.isValid());
     SkBitmap bm;
-    if (!codec->decode(&stream, &bm, gPrefConfig, SkImageDecoder::kDecodePixels_Mode)) {
+    if (!codec->decode(&stream, &bm, gPrefColorType, SkImageDecoder::kDecodePixels_Mode)) {
         gDecodeFailures.push_back().appendf("Without using getLength, %s failed to decode\n",
                                             srcPath);
         return;
     }
     skiagm::GmResultDigest lengthLessDigest(bm);
     if (!lengthLessDigest.isValid()) {
         gDecodeFailures.push_back().appendf("Without using getLength, %s failed to build "
                                             "a digest\n", srcPath);
         return;
     }
@@ skipping 44 matching lines @@
 
     // Create a string representing just the filename itself, for use in json expectations.
     SkString basename = SkOSPath::SkBasename(srcPath);
     // Replace '_' with '-', so that the names can fit gm_json.py's IMAGE_FILENAME_PATTERN
     replace_char(&basename, '_', '-');
     // Replace '.' with '-', so the output filename can still retain the original file extension,
     // but still end up with only one '.', which denotes the actual extension of the final file.
     replace_char(&basename, '.', '-');
     const char* filename = basename.c_str();
 
-    if (!codec->decode(&stream, &bitmap, gPrefConfig,
-                       SkImageDecoder::kDecodePixels_Mode)) {
+    if (!codec->decode(&stream, &bitmap, gPrefColorType, SkImageDecoder::kDecodePixels_Mode)) {
         if (NULL != gJsonExpectations.get()) {
             const SkString name_config = create_json_key(filename);
             skiagm::Expectations jsExpectations = gJsonExpectations->get(name_config.c_str());
             if (jsExpectations.ignoreFailure()) {
                 // This is a known failure.
                 gKnownFailures.push_back().appendf(
                     "failed to decode %s, which is a known failure.", srcPath);
                 return;
             }
             if (jsExpectations.empty()) {
@@ skipping 65 matching lines @@
         if (codec->buildTileIndex(&stream, &width, &height) && width > 1 && height > 1) {
             SkASSERT(bitmap.width() == width && bitmap.height() == height);
             // Call decodeSubset multiple times:
             SkRandom rand(0);
             for (int i = 0; i < 5; i++) {
                 SkBitmap bitmapFromDecodeSubset;
                 // FIXME: Come up with a more representative set of rectangles.
                 SkIRect rect = generate_random_rect(&rand, width, height);
                 SkString subsetDim = SkStringPrintf("%d_%d_%d_%d", rect.fLeft, rect.fTop,
                                                     rect.fRight, rect.fBottom);
-                if (codec->decodeSubset(&bitmapFromDecodeSubset, rect, gPrefConfig)) {
+                if (codec->decodeSubset(&bitmapFromDecodeSubset, rect, gPrefColorType)) {
                     SkString subsetName = SkStringPrintf("%s-%s", filename, subsetDim.c_str());
                     skiagm::BitmapAndDigest subsetBitmapAndDigest(bitmapFromDecodeSubset);
                     if (compare_to_expectations_if_necessary(subsetBitmapAndDigest.fDigest,
                                                              subsetName.c_str(),
                                                              &gFailedSubsetDecodes,
                                                              &gMissingSubsetExpectations,
                                                              &gKnownSubsetFailures)) {
                         gSuccessfulSubsetDecodes.push_back().printf("Decoded subset %s from %s",
                                                               subsetDim.c_str(), srcPath);
                     } else if (!FLAGS_mismatchPath.isEmpty()) {
                         write_subset(FLAGS_mismatchPath[0], subsetName,
                                      subsetBitmapAndDigest, rect, bitmap);
                     }
 
                     write_expectations(subsetBitmapAndDigest, subsetName.c_str());
 
                     if (writePath != NULL) {
                         write_subset(writePath->c_str(), subsetName,
                                      subsetBitmapAndDigest, rect, bitmap);
                     }
                 } else {
                     gFailedSubsetDecodes.push_back().printf("Failed to decode region %s from %s",
                                                             subsetDim.c_str(), srcPath);
                 }
             }
         }
     }
 
     // Do not attempt to re-encode A8, since our image encoders do not support encoding to A8.
-    if (FLAGS_reencode && bitmap.config() != SkBitmap::kA8_Config) {
+    if (FLAGS_reencode && bitmap.colorType() != kAlpha_8_SkColorType) {
         // Encode to the format the file was originally in, or PNG if the encoder for the same
         // format is unavailable.
         SkImageDecoder::Format format = codec->getFormat();
         if (SkImageDecoder::kUnknown_Format == format) {
             if (stream.rewind()) {
                 format = SkImageDecoder::GetStreamFormat(&stream);
             }
             if (SkImageDecoder::kUnknown_Format == format) {
                 const char* dot = strrchr(srcPath, '.');
                 if (NULL != dot) {
@@ skipping 36 matching lines @@
             if(file.write(data->data(), data->size())) {
                 gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
             } else {
                 gEncodeFailures.push_back().printf("Failed to write %s", outPath.c_str());
             }
         }
         // Ensure that the reencoded data can still be decoded.
         SkMemoryStream memStream(data);
         SkBitmap redecodedBitmap;
         SkImageDecoder::Format formatOnSecondDecode;
-        if (SkImageDecoder::DecodeStream(&memStream, &redecodedBitmap, gPrefConfig,
-                                          SkImageDecoder::kDecodePixels_Mode,
-                                          &formatOnSecondDecode)) {
+        if (SkImageDecoder::DecodeStream(&memStream, &redecodedBitmap, gPrefColorType,
+                                         SkImageDecoder::kDecodePixels_Mode,
+                                         &formatOnSecondDecode)) {
             SkASSERT(format_to_type(formatOnSecondDecode) == type);
         } else {
             gDecodeFailures.push_back().printf("Failed to redecode %s after reencoding to '%s'",
                                                srcPath, suffix_for_type(type));
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 65 matching lines @@
         append_path_separator_if_necessary(&outDir);
         outDirPtr = &outDir;
     } else {
         outDirPtr = NULL;
     }
 
     if (FLAGS_config.count() == 1) {
         // Only consider the first config specified on the command line.
         const char* config = FLAGS_config[0];
         if (0 == strcmp(config, "8888")) {
-            gPrefConfig = SkBitmap::kARGB_8888_Config;
+            gPrefColorType = kN32_SkColorType;
         } else if (0 == strcmp(config, "565")) {
-            gPrefConfig = SkBitmap::kRGB_565_Config;
+            gPrefColorType = kRGB_565_SkColorType;
         } else if (0 == strcmp(config, "A8")) {
-            gPrefConfig = SkBitmap::kA8_Config;
+            gPrefColorType = kAlpha_8_SkColorType;
         } else if (0 != strcmp(config, "None")) {
             SkDebugf("Invalid preferred config\n");
             return -1;
         }
     }
 
     for (int i = 0; i < FLAGS_readPath.count(); i++) {
         const char* readPath = FLAGS_readPath[i];
         if (strlen(readPath) < 1) {
             break;
@@ skipping 44 matching lines @@
     print_strings("Known failures", gKnownFailures);
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif