Rename SkBitmapRegionDecoder and Create function

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
@@ skipping 363 matching lines @@
 
     for (int sampleSize : sampleSizes) {
         for (AndroidCodecSrc::Mode mode : androidModes) {
             for (uint32_t i = 0; i < numColorTypes; i++) {
                 push_android_codec_src(path, mode, colorTypes[i], sampleSize);
             }
         }
     }
 }
 
-static bool brd_color_type_supported(SkBitmapRegionDecoderInterface::Strategy strategy,
+static bool brd_color_type_supported(SkBitmapRegionDecoder::Strategy strategy,
         CodecSrc::DstColorType dstColorType) {
     switch (strategy) {
-        case SkBitmapRegionDecoderInterface::kCanvas_Strategy:
+        case SkBitmapRegionDecoder::kCanvas_Strategy:
             if (CodecSrc::kGetFromCanvas_DstColorType == dstColorType) {
                 return true;
             }
             return false;
-        case SkBitmapRegionDecoderInterface::kOriginal_Strategy:
+        case SkBitmapRegionDecoder::kOriginal_Strategy:
             switch (dstColorType) {
                 case CodecSrc::kGetFromCanvas_DstColorType:
                 case CodecSrc::kIndex8_Always_DstColorType:
                 case CodecSrc::kGrayscale_Always_DstColorType:
                     return true;
                 default:
                     return false;
             }
-        case SkBitmapRegionDecoderInterface::kAndroidCodec_Strategy:
+        case SkBitmapRegionDecoder::kAndroidCodec_Strategy:
             switch (dstColorType) {
                 case CodecSrc::kGetFromCanvas_DstColorType:
                 case CodecSrc::kIndex8_Always_DstColorType:
                 case CodecSrc::kGrayscale_Always_DstColorType:
                     return true;
                 default:
                     return false;
             }
         default:
             SkASSERT(false);
             return false;
     }
 }
 
-static void push_brd_src(Path path, SkBitmapRegionDecoderInterface::Strategy strategy,
+static void push_brd_src(Path path, SkBitmapRegionDecoder::Strategy strategy,
         CodecSrc::DstColorType dstColorType, BRDSrc::Mode mode, uint32_t sampleSize) {
     SkString folder;
     switch (strategy) {
-        case SkBitmapRegionDecoderInterface::kCanvas_Strategy:
+        case SkBitmapRegionDecoder::kCanvas_Strategy:
             folder.append("brd_canvas");
             break;
-        case SkBitmapRegionDecoderInterface::kOriginal_Strategy:
+        case SkBitmapRegionDecoder::kOriginal_Strategy:
             folder.append("brd_sample");
             break;
-        case SkBitmapRegionDecoderInterface::kAndroidCodec_Strategy:
+        case SkBitmapRegionDecoder::kAndroidCodec_Strategy:
             folder.append("brd_android_codec");
             break;
         default:
             SkASSERT(false);
             return;
     }
 
     switch (mode) {
         case BRDSrc::kFullImage_Mode:
             break;
@@ skipping 22 matching lines @@
     if (1 != sampleSize) {
         folder.appendf("_%.3f", get_scale_from_sample_size(sampleSize));
     }
 
     BRDSrc* src = new BRDSrc(path, strategy, mode, dstColorType, sampleSize);
     push_src("image", folder, src);
 }
 
 static void push_brd_srcs(Path path) {
 
-    const SkBitmapRegionDecoderInterface::Strategy strategies[] = {
-            SkBitmapRegionDecoderInterface::kCanvas_Strategy,
-            SkBitmapRegionDecoderInterface::kOriginal_Strategy,
-            SkBitmapRegionDecoderInterface::kAndroidCodec_Strategy,
+    const SkBitmapRegionDecoder::Strategy strategies[] = {
+            SkBitmapRegionDecoder::kCanvas_Strategy,
+            SkBitmapRegionDecoder::kOriginal_Strategy,
+            SkBitmapRegionDecoder::kAndroidCodec_Strategy,
     };
 
     // Test on a variety of sampleSizes, making sure to include:
     // - 2, 4, and 8, which are natively supported by jpeg
     // - multiples of 2 which are not divisible by 4 (analogous for 4)
     // - larger powers of two, since BRD clients generally use powers of 2
     // We will only produce output for the larger sizes on large images.
     const uint32_t sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 24, 32, 64 };
 
     // We will only test to one backend (8888), but we will test all of the
     // color types that we need to decode to on this backend.
     const CodecSrc::DstColorType dstColorTypes[] = {
             CodecSrc::kGetFromCanvas_DstColorType,
             CodecSrc::kIndex8_Always_DstColorType,
             CodecSrc::kGrayscale_Always_DstColorType,
     };
 
     const BRDSrc::Mode modes[] = {
             BRDSrc::kFullImage_Mode,
             BRDSrc::kDivisor_Mode,
     };
 
-    for (SkBitmapRegionDecoderInterface::Strategy strategy : strategies) {
+    for (SkBitmapRegionDecoder::Strategy strategy : strategies) {
 
         // We disable png testing for kOriginal_Strategy because the implementation leaks
         // memory in our forked libpng.
         // TODO (msarett): Decide if we want to test pngs in this mode and how we might do this.
-        if (SkBitmapRegionDecoderInterface::kOriginal_Strategy == strategy &&
+        if (SkBitmapRegionDecoder::kOriginal_Strategy == strategy &&
                 (path.endsWith(".png") || path.endsWith(".PNG"))) {
             continue;
         }
         for (uint32_t sampleSize : sampleSizes) {
 
             // kOriginal_Strategy does not work for jpegs that are scaled to non-powers of two.
             // We don't need to test this.  We know it doesn't work, and it causes images with
             // uninitialized memory to show up on Gold.
-            if (SkBitmapRegionDecoderInterface::kOriginal_Strategy == strategy &&
+            if (SkBitmapRegionDecoder::kOriginal_Strategy == strategy &&
                     (path.endsWith(".jpg") || path.endsWith(".JPG") ||
                     path.endsWith(".jpeg") || path.endsWith(".JPEG")) && !SkIsPow2(sampleSize)) {
                 continue;
             }
             for (CodecSrc::DstColorType dstColorType : dstColorTypes) {
                 if (brd_color_type_supported(strategy, dstColorType)) {
                     for (BRDSrc::Mode mode : modes) {
                         push_brd_src(path, strategy, dstColorType, mode, sampleSize);
                     }
                 }
@@ skipping 648 matching lines @@
     #endif  // SK_PDF_IMAGE_STATS
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif