Finish supporting decoding opaque to non-opaque

tests/CodecTest.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 "Resources.h"
 #include "SkAndroidCodec.h"
 #include "SkBitmap.h"
@@ skipping 85 matching lines @@
     REPORTER_ASSERT(r, result == expectedResult);
 
     md5(bm, digest);
     if (goodDigest) {
         REPORTER_ASSERT(r, *digest == *goodDigest);
     }
 
     {
         // Test decoding to 565
         SkImageInfo info565 = info.makeColorType(kRGB_565_SkColorType);
-        SkCodec::Result expected565 = info.alphaType() == kOpaque_SkAlphaType ?
-                expectedResult : SkCodec::kInvalidConversion;
-        test_info(r, codec, info565, expected565, nullptr);
+        if (info.alphaType() == kOpaque_SkAlphaType) {
+            // Decoding to 565 should succeed.
+            SkBitmap bm565;
+            bm565.allocPixels(info565);
+            SkAutoLockPixels alp(bm565);
+
+            // This will allow comparison even if the image is incomplete.
+            bm565.eraseColor(SK_ColorBLACK);
+
+            REPORTER_ASSERT(r, expectedResult == codec->getPixels(info565,
+                    bm565.getPixels(), bm565.rowBytes()));
+
+            SkMD5::Digest digest565;
+            md5(bm565, &digest565);
+
+            // A dumb client's request for non-opaque should also succeed.
+            for (auto alpha : { kPremul_SkAlphaType, kUnpremul_SkAlphaType }) {
+                info565 = info565.makeAlphaType(alpha);
+                test_info(r, codec, info565, expectedResult, &digest565);
+            }
+        } else {
+            test_info(r, codec, info565, SkCodec::kInvalidConversion, nullptr);
+        }
+    }
+
+    if (codec->getInfo().colorType() == kGray_8_SkColorType) {
+        SkImageInfo grayInfo = codec->getInfo();
+        SkBitmap grayBm;
+        grayBm.allocPixels(grayInfo);
+        SkAutoLockPixels alp(grayBm);
+
+        grayBm.eraseColor(SK_ColorBLACK);
+
+        REPORTER_ASSERT(r, expectedResult == codec->getPixels(grayInfo,
+                grayBm.getPixels(), grayBm.rowBytes()));
+
+        SkMD5::Digest grayDigest;
+        md5(grayBm, &grayDigest);
+
+        for (auto alpha : { kPremul_SkAlphaType, kUnpremul_SkAlphaType }) {
+            grayInfo = grayInfo.makeAlphaType(alpha);
+            test_info(r, codec, grayInfo, expectedResult, &grayDigest);
+        }
     }
 
     // Verify that re-decoding gives the same result.  It is interesting to check this after
     // a decode to 565, since choosing to decode to 565 may result in some of the decode
     // options being modified.  These options should return to their defaults on another
     // decode to kN32, so the new digest should match the old digest.
     test_info(r, codec, info, expectedResult, digest);
 
     {
         // Check alpha type conversions
@@ skipping 846 matching lines @@
     // Now test an image which is too big. Any image with a larger header (i.e.
     // has bigger width/height) is also too big.
     const unsigned char tooBigWbmp[] = { 0x00, 0x00,           // Header
                                          0x84, 0x80, 0x00,     // W: 65536
                                          0x84, 0x80, 0x00 };   // H: 65536
     stream.reset(new SkMemoryStream(tooBigWbmp, sizeof(tooBigWbmp), false));
     codec.reset(SkCodec::NewFromStream(stream.release()));
 
     REPORTER_ASSERT(r, !codec);
 }