SkCodec no longer inherits from SkImageGenerator.

dm/DMSrcSink.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCodec.h"
@@ skipping 125 matching lines @@
     SkBitmap bitmap;
     if (!bitmap.tryAllocPixels(decodeInfo, NULL, colorTable.get())) {
         return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     switch (fMode) {
         case kNormal_Mode: {
             switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), NULL,
                     colorPtr, colorCountPtr)) {
-                case SkImageGenerator::kSuccess:
+                case SkCodec::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
-                case SkImageGenerator::kIncompleteInput:
+                case SkCodec::kIncompleteInput:
                     break;
-                case SkImageGenerator::kInvalidConversion:
+                case SkCodec::kInvalidConversion:
                     return Error::Nonfatal("Incompatible colortype conversion");
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
             SkScanlineDecoder* scanlineDecoder = codec->getScanlineDecoder(decodeInfo, NULL,
                     colorPtr, colorCountPtr);
             if (NULL == scanlineDecoder) {
                 return Error::Nonfatal("Cannot use scanline decoder for all images");
             }
-            const SkImageGenerator::Result result = scanlineDecoder->getScanlines(
+            const SkCodec::Result result = scanlineDecoder->getScanlines(
                     bitmap.getAddr(0, 0), decodeInfo.height(), bitmap.rowBytes());
             switch (result) {
-                case SkImageGenerator::kSuccess:
-                case SkImageGenerator::kIncompleteInput:
+                case SkCodec::kSuccess:
+                case SkCodec::kIncompleteInput:
                     break;
                 default:
                     return SkStringPrintf("%s failed with error message %d",
                                           fPath.c_str(), (int) result);
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Subset_Mode: {
             //this mode decodes the image in divisor*divisor subsets, using a scanline decoder
@@ skipping 43 matching lines @@
                             NULL, colorPtr, colorCountPtr);
                     if (NULL == subsetScanlineDecoder) {
                         if (x == 0 && y == 0) {
                             //first try, image may not be compatible
                             return Error::Nonfatal("Cannot use scanline decoder for all images");
                         } else {
                             return "Error scanline decoder is NULL";
                         }
                     }
                     //skip to first line of subset
-                    const SkImageGenerator::Result skipResult =
+                    const SkCodec::Result skipResult =
                             subsetScanlineDecoder->skipScanlines(y);
                     switch (skipResult) {
-                        case SkImageGenerator::kSuccess:
-                        case SkImageGenerator::kIncompleteInput:
+                        case SkCodec::kSuccess:
+                        case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("%s failed after attempting to skip %d scanlines"
                                     "with error message %d", fPath.c_str(), y, (int) skipResult);
                     }
                     //create and set size of subsetBm
                     SkBitmap subsetBm;
                     SkIRect bounds = SkIRect::MakeWH(subsetWidth, subsetHeight);
                     bounds.setXYWH(0, 0, currentSubsetWidth, currentSubsetHeight);
                     SkAssertResult(largestSubsetBm.extractSubset(&subsetBm, bounds));
                     SkAutoLockPixels autlockSubsetBm(subsetBm, true);
-                    const SkImageGenerator::Result subsetResult =
+                    const SkCodec::Result subsetResult =
                         subsetScanlineDecoder->getScanlines(buffer, currentSubsetHeight, rowBytes);
                     switch (subsetResult) {
-                        case SkImageGenerator::kSuccess:
-                        case SkImageGenerator::kIncompleteInput:
+                        case SkCodec::kSuccess:
+                        case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("%s failed with error message %d",
                                     fPath.c_str(), (int) subsetResult);
                     }
                     const size_t bpp = decodeInfo.bytesPerPixel();
                     /*
                      * we copy all the lines at once becuase when calling getScanlines for
                      * interlaced pngs the entire image must be read regardless of the number
                      * of lines requested.  Reading an interlaced png in a loop, line-by-line, would
@@ skipping 23 matching lines @@
 
             // Decode odd stripes
             SkScanlineDecoder* decoder = codec->getScanlineDecoder(decodeInfo, NULL, colorPtr,
                     colorCountPtr);
             if (NULL == decoder) {
                 return Error::Nonfatal("Cannot use scanline decoder for all images");
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);
-                SkImageGenerator::Result result = decoder->skipScanlines(linesToSkip);
+                SkCodec::Result result = decoder->skipScanlines(linesToSkip);
                 switch (result) {
-                    case SkImageGenerator::kSuccess:
-                    case SkImageGenerator::kIncompleteInput:
+                    case SkCodec::kSuccess:
+                    case SkCodec::kIncompleteInput:
                         break;
                     default:
                         return SkStringPrintf("Cannot skip scanlines for %s.", fPath.c_str());
                 }
 
                 // Read a stripe
                 const int startY = (i + 1) * stripeHeight;
                 const int linesToRead = SkTMin(stripeHeight, height - startY);
                 if (linesToRead > 0) {
                     result = decoder->getScanlines(bitmap.getAddr(0, startY),
                             linesToRead, bitmap.rowBytes());
                     switch (result) {
-                        case SkImageGenerator::kSuccess:
-                        case SkImageGenerator::kIncompleteInput:
+                        case SkCodec::kSuccess:
+                        case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("Cannot get scanlines for %s.", fPath.c_str());
                     }
                 }
             }
 
             // Decode even stripes
             decoder = codec->getScanlineDecoder(decodeInfo, NULL, colorPtr, colorCountPtr);
             if (NULL == decoder) {
                 return "Failed to create second scanline decoder.";
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Read a stripe
                 const int startY = i * stripeHeight;
                 const int linesToRead = SkTMin(stripeHeight, height - startY);
-                SkImageGenerator::Result result = decoder->getScanlines(bitmap.getAddr(0, startY),
+                SkCodec::Result result = decoder->getScanlines(bitmap.getAddr(0, startY),
                         linesToRead, bitmap.rowBytes());
                 switch (result) {
-                    case SkImageGenerator::kSuccess:
-                    case SkImageGenerator::kIncompleteInput:
+                    case SkCodec::kSuccess:
+                    case SkCodec::kIncompleteInput:
                         break;
                     default:
                         return SkStringPrintf("Cannot get scanlines for %s.", fPath.c_str());
                 }
 
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - (i + 1) * stripeHeight);
                 if (linesToSkip > 0) {
                     result = decoder->skipScanlines(linesToSkip);
                     switch (result) {
-                        case SkImageGenerator::kSuccess:
-                        case SkImageGenerator::kIncompleteInput:
+                        case SkCodec::kSuccess:
+                        case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("Cannot skip scanlines for %s.", fPath.c_str());
                     }
                 }
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
     }
@@ skipping 630 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM