Qualify the return value of SkImageDecoder::decode

src/images/SkImageDecoder_ktx.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
 #include "SkImageDecoder.h"
 #include "SkPixelRef.h"
@@ skipping 23 matching lines @@
 
 class SkKTXImageDecoder : public SkImageDecoder {
 public:
     SkKTXImageDecoder() { }
 
     virtual Format getFormat() const SK_OVERRIDE {
         return kKTX_Format;
     }
 
 protected:
-    virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+    virtual Result onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
     typedef SkImageDecoder INHERITED;
 };
 
-bool SkKTXImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
+SkImageDecoder::Result SkKTXImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     // TODO: Implement SkStream::copyToData() that's cheap for memory and file streams
     SkAutoDataUnref data(SkCopyStreamToData(stream));
     if (NULL == data) {
-        return false;
+        return kFailure;
     }
 
     SkKTXFile ktxFile(data);
     if (!ktxFile.valid()) {
-        return false;
+        return kFailure;
     }
 
     const unsigned short width = ktxFile.width();
     const unsigned short height = ktxFile.height();
 
 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
     // should we allow the Chooser (if present) to pick a config for us???
     if (!this->chooseFromOneChoice(kN32_SkColorType, width, height)) {
-        return false;
+        return kFailure;
     }
 #endif
 
     // Set a flag if our source is premultiplied alpha
     const SkString premulKey("KTXPremultipliedAlpha");
     const bool bSrcIsPremul = ktxFile.getValueForKey(premulKey) == SkString("True");
 
     // Setup the sampler...
     SkScaledBitmapSampler sampler(width, height, this->getSampleSize());
 
     // Determine the alpha of the bitmap...
     SkAlphaType alphaType = kOpaque_SkAlphaType;
     if (ktxFile.isRGBA8()) {
         if (this->getRequireUnpremultipliedColors()) {
             alphaType = kUnpremul_SkAlphaType;
             // If the client wants unpremul colors and we only have
             // premul, then we cannot honor their wish.
             if (bSrcIsPremul) {
-                return false;
+                return kFailure;
             }
         } else {
             alphaType = kPremul_SkAlphaType;
         }
     }
 
     // Search through the compressed formats to see if the KTX file is holding
     // compressed data
     bool ktxIsCompressed = false;
     SkTextureCompressor::Format ktxCompressedFormat;
@@ skipping 16 matching lines @@
         const int w = sampler.scaledWidth();
         const int h = sampler.scaledHeight();
         bm->setInfo(SkImageInfo::MakeA8(w, h));
     } else {
         const int w = sampler.scaledWidth();
         const int h = sampler.scaledHeight();
         bm->setInfo(SkImageInfo::MakeN32(w, h, alphaType));
     }
     
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
-        return true;
+        return kSuccess;
     }
 
     // If we've made it this far, then we know how to grok the data.
     if (!this->allocPixelRef(bm, NULL)) {
-        return false;
+        return kFailure;
     }
 
     // Lock the pixels, since we're about to write to them...
     SkAutoLockPixels alp(*bm);
 
     if (isCompressedAlpha) {
         if (!sampler.begin(bm, SkScaledBitmapSampler::kGray, *this)) {
-            return false;
+            return kFailure;
         }
 
         // Alpha data is only a single byte per pixel.
         int nPixels = width * height;
         SkAutoMalloc outRGBData(nPixels);
         uint8_t *outRGBDataPtr = reinterpret_cast<uint8_t *>(outRGBData.get());
 
         // Decode the compressed format
         const uint8_t *buf = reinterpret_cast<const uint8_t *>(ktxFile.pixelData());
         if (!SkTextureCompressor::DecompressBufferFromFormat(
                 outRGBDataPtr, width, buf, width, height, ktxCompressedFormat)) {
-            return false;
+            return kFailure;
         }
 
         // Set each of the pixels...
         const int srcRowBytes = width;
         const int dstHeight = sampler.scaledHeight();
         const uint8_t *srcRow = reinterpret_cast<uint8_t *>(outRGBDataPtr);
         srcRow += sampler.srcY0() * srcRowBytes;
         for (int y = 0; y < dstHeight; ++y) {
             sampler.next(srcRow);
             srcRow += sampler.srcDY() * srcRowBytes;
         }
 
-        return true;
+        return kSuccess;
 
     } else if (ktxFile.isCompressedFormat(SkTextureCompressor::kETC1_Format)) {
         if (!sampler.begin(bm, SkScaledBitmapSampler::kRGB, *this)) {
-            return false;
+            return kFailure;
         }
 
         // ETC1 Data is encoded as RGB pixels, so we should extract it as such
         int nPixels = width * height;
         SkAutoMalloc outRGBData(nPixels * 3);
         uint8_t *outRGBDataPtr = reinterpret_cast<uint8_t *>(outRGBData.get());
 
         // Decode ETC1
         const uint8_t *buf = reinterpret_cast<const uint8_t *>(ktxFile.pixelData());
         if (!SkTextureCompressor::DecompressBufferFromFormat(
                 outRGBDataPtr, width*3, buf, width, height, SkTextureCompressor::kETC1_Format)) {
-            return false;
+            return kFailure;
         }
 
         // Set each of the pixels...
         const int srcRowBytes = width * 3;
         const int dstHeight = sampler.scaledHeight();
         const uint8_t *srcRow = reinterpret_cast<uint8_t *>(outRGBDataPtr);
         srcRow += sampler.srcY0() * srcRowBytes;
         for (int y = 0; y < dstHeight; ++y) {
             sampler.next(srcRow);
             srcRow += sampler.srcDY() * srcRowBytes;
         }
 
-        return true;
+        return kSuccess;
 
     } else if (ktxFile.isRGB8()) {
 
         // Uncompressed RGB data (without alpha)
         if (!sampler.begin(bm, SkScaledBitmapSampler::kRGB, *this)) {
-            return false;
+            return kFailure;
         }
 
         // Just need to read RGB pixels
         const int srcRowBytes = width * 3;
         const int dstHeight = sampler.scaledHeight();
         const uint8_t *srcRow = reinterpret_cast<const uint8_t *>(ktxFile.pixelData());
         srcRow += sampler.srcY0() * srcRowBytes;
         for (int y = 0; y < dstHeight; ++y) {
             sampler.next(srcRow);
             srcRow += sampler.srcDY() * srcRowBytes;
         }
 
-        return true;
+        return kSuccess;
 
     } else if (ktxFile.isRGBA8()) {
 
         // Uncompressed RGBA data
 
         // If we know that the image contains premultiplied alpha, then
         // we need to turn off the premultiplier
         SkScaledBitmapSampler::Options opts (*this);
         if (bSrcIsPremul) {
             SkASSERT(bm->alphaType() == kPremul_SkAlphaType);
             SkASSERT(!this->getRequireUnpremultipliedColors());
 
             opts.fPremultiplyAlpha = false;
         } 
 
         if (!sampler.begin(bm, SkScaledBitmapSampler::kRGBA, opts)) {
-            return false;
+            return kFailure;
         }
 
         // Just need to read RGBA pixels
         const int srcRowBytes = width * 4;
         const int dstHeight = sampler.scaledHeight();
         const uint8_t *srcRow = reinterpret_cast<const uint8_t *>(ktxFile.pixelData());
         srcRow += sampler.srcY0() * srcRowBytes;
         for (int y = 0; y < dstHeight; ++y) {
             sampler.next(srcRow);
             srcRow += sampler.srcDY() * srcRowBytes;
         }
 
-        return true;
+        return kSuccess;
     }
 
-    return false;
+    return kFailure;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // KTX Image Encoder
 //
 // This encoder takes a best guess at how to encode the bitmap passed to it. If
 // there is an installed discardable pixel ref with existing PKM data, then we
 // will repurpose the existing ETC1 data into a KTX file. If the data contains
 // KTX data, then we simply return a copy of the same data. For all other files,
@@ skipping 74 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libktx_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kKTX_Type == t) ? SkNEW(SkKTXImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gReg(sk_libktx_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_ktx);
 static SkImageEncoder_EncodeReg gEReg(sk_libktx_efactory);