Make kInvalidConversion a fatal failure in DMSrcSink

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 "SkAndroidCodec.h"
 #include "SkCodec.h"
@@ skipping 303 matching lines @@
 bool get_decode_info(SkImageInfo* decodeInfo, SkColorType canvasColorType,
                      CodecSrc::DstColorType dstColorType) {
     switch (dstColorType) {
         case CodecSrc::kIndex8_Always_DstColorType:
             if (kRGB_565_SkColorType == canvasColorType) {
                 return false;
             }
             *decodeInfo = decodeInfo->makeColorType(kIndex_8_SkColorType);
             break;
         case CodecSrc::kGrayscale_Always_DstColorType:
-            if (kRGB_565_SkColorType == canvasColorType) {
+            if (kRGB_565_SkColorType == canvasColorType ||
+                    kOpaque_SkAlphaType != decodeInfo->alphaType()) {

[scroggo, 2016/02/16 21:13:25]

We only attempt gray if the codec reports it as the default, right? Does this
case ever get hit? It seems like this would imply that the image reported gray +
alpha?

[msarett, 2016/02/16 21:14:51]

It gets hit because we now test kOpaque images to kOpaque, kPremul, and
kUnpremul.

                 return false;
             }
             *decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
             break;
         default:
+            if (kRGB_565_SkColorType == canvasColorType &&
+                    kOpaque_SkAlphaType != decodeInfo->alphaType()) {
+                return false;
+            }
             *decodeInfo = decodeInfo->makeColorType(canvasColorType);
             break;
     }
 
     return true;
 }
 
 Error test_gen(SkCanvas* canvas, SkData* data) {
     SkAutoTDelete<SkImageGenerator> gen = SkCodecImageGenerator::NewFromEncodedCodec(data);
     if (!gen) {
@@ skipping 81 matching lines @@
     switch (fMode) {
         case kCodecZeroInit_Mode:
         case kCodec_Mode: {
             switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), &options,
                     colorPtr, colorCountPtr)) {
                 case SkCodec::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
                 case SkCodec::kIncompleteInput:
                     break;
-                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());
             }
             premultiply_if_necessary(bitmap);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
             if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
@@ skipping 250 matching lines @@
     options.fColorCount = colorCountPtr;
     options.fSampleSize = fSampleSize;
 
     switch (fMode) {
         case kFullImage_Mode: {
             switch (codec->getAndroidPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(),
                     &options)) {
                 case SkCodec::kSuccess:
                 case SkCodec::kIncompleteInput:
                     break;
-                case SkCodec::kInvalidConversion:
-                    return Error::Nonfatal("Cannot convert to requested color type.");
                 default:
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             premultiply_if_necessary(bitmap);
             canvas->drawBitmap(bitmap, 0, 0);
             return "";
         }
         case kDivisor_Mode: {
             const int width = codec->getInfo().width();
             const int height = codec->getInfo().height();
@@ skipping 695 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return check_against_reference(bitmap, src, fSink);
     });
 }
 
 }  // namespace DM