Qualify the return value of SkImageDecoder::decode

src/images/SkImageDecoder_libgif.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkImageDecoder.h"
 #include "SkRTConf.h"
 #include "SkScaledBitmapSampler.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
 
 #include "gif_lib.h"
 
 class SkGIFImageDecoder : public SkImageDecoder {
 public:
     virtual Format getFormat() const SK_OVERRIDE {
         return kGIF_Format;
     }
 
 protected:
-    virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
+    virtual Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
 
 private:
     typedef SkImageDecoder INHERITED;
 };
 
 static const uint8_t gStartingIterlaceYValue[] = {
     0, 4, 2, 1
 };
 static const uint8_t gDeltaIterlaceYValue[] = {
     8, 8, 4, 2
@@ skipping 107 matching lines @@
                 if (transpIndex >= colorCount) {
                     transpIndex = -1;
                 }
                 break;
             }
         }
     }
     return transpIndex;
 }
 
-static bool error_return(const SkBitmap& bm, const char msg[]) {
+static SkImageDecoder::Result error_return(const SkBitmap& bm, const char msg[]) {
     if (!c_suppressGIFImageDecoderWarnings) {
         SkDebugf("libgif error [%s] bitmap [%d %d] pixels %p colortable %p\n",
                  msg, bm.width(), bm.height(), bm.getPixels(),
                  bm.getColorTable());
     }
-    return false;
+    return SkImageDecoder::kFailure;
 }
+
 static void gif_warning(const SkBitmap& bm, const char msg[]) {
     if (!c_suppressGIFImageDecoderWarnings) {
         SkDebugf("libgif warning [%s] bitmap [%d %d] pixels %p colortable %p\n",
                  msg, bm.width(), bm.height(), bm.getPixels(),
                  bm.getColorTable());
     }
 }
 
 /**
  *  Skip rows in the source gif image.
@@ skipping 48 matching lines @@
                     addr += rowBytes;
                 }
                 if (warning) {
                     gif_warning(*bm, "Index out of bounds.");
                 }
             }
         }
     }
 }
 
-bool SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, Mode mode) {
+SkImageDecoder::Result SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, Mode mode) {
 #if GIFLIB_MAJOR < 5
     GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc);
 #else
     GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc, NULL);
 #endif
     if (NULL == gif) {
         return error_return(*bm, "DGifOpen");
     }
 
     SkAutoTCallIProc<GifFileType, DGifCloseFile> acp(gif);
@@ skipping 73 matching lines @@
                 return error_return(*bm, "chooseFromOneChoice");
             }
 #endif
 
             SkScaledBitmapSampler sampler(width, height, this->getSampleSize());
 
             bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
                                           kIndex_8_SkColorType, kPremul_SkAlphaType));
 
             if (SkImageDecoder::kDecodeBounds_Mode == mode) {
-                return true;
+                return kSuccess;
             }
 
 
             // now we decode the colortable
             int colorCount = 0;
             {
                 // Declare colorPtr here for scope.
                 SkPMColor colorPtr[256]; // storage for worst-case
                 const ColorMapObject* cmap = find_colormap(gif);
                 if (cmap != NULL) {
@@ skipping 80 matching lines @@
                 // take care of skipping unneeded rows.
                 GifInterlaceIter iter(innerHeight);
                 for (int y = 0; y < innerHeight; y++) {
                     if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) {
                         gif_warning(*bm, "interlace DGifGetLine");
                         memset(scanline, fillIndex, innerWidth);
                         for (; y < innerHeight; y++) {
                             sampler.sampleInterlaced(scanline, iter.currY());
                             iter.next();
                         }
-                        return true;
+                        return kPartialSuccess;
                     }
                     sampler.sampleInterlaced(scanline, iter.currY());
                     iter.next();
                 }
             } else {
                 // easy, non-interlace case
                 const int outHeight = workingBitmap->height();
                 skip_src_rows(gif, scanline, innerWidth, sampler.srcY0());
                 for (int y = 0; y < outHeight; y++) {
                     if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) {
                         gif_warning(*bm, "DGifGetLine");
                         memset(scanline, fillIndex, innerWidth);
                         for (; y < outHeight; y++) {
                             sampler.next(scanline);
                         }
-                        return true;
+                        return kPartialSuccess;
                     }
                     // scanline now contains the raw data. Sample it.
                     sampler.next(scanline);
                     if (y < outHeight - 1) {
                         skip_src_rows(gif, scanline, innerWidth, sampler.srcDY() - 1);
                     }
                 }
                 // skip the rest of the rows (if any)
                 int read = (outHeight - 1) * sampler.srcDY() + sampler.srcY0() + 1;
                 SkASSERT(read <= innerHeight);
                 skip_src_rows(gif, scanline, innerWidth, innerHeight - read);
             }
             sanitize_indexed_bitmap(bm);
-            return true;
+            return kSuccess;
             } break;
 
         case EXTENSION_RECORD_TYPE:
 #if GIFLIB_MAJOR < 5
             if (DGifGetExtension(gif, &temp_save.Function,
                                  &extData) == GIF_ERROR) {
 #else
             if (DGifGetExtension(gif, &extFunction, &extData) == GIF_ERROR) {
 #endif
                 return error_return(*bm, "DGifGetExtension");
@@ skipping 24 matching lines @@
 
         case TERMINATE_RECORD_TYPE:
             break;
 
         default:    /* Should be trapped by DGifGetRecordType */
             break;
         }
     } while (recType != TERMINATE_RECORD_TYPE);
 
     sanitize_indexed_bitmap(bm);
-    return true;
+    return kSuccess;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 DEFINE_DECODER_CREATOR(GIFImageDecoder);
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool is_gif(SkStreamRewindable* stream) {
     char buf[GIF_STAMP_LEN];
     if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) {
         if (memcmp(GIF_STAMP,   buf, GIF_STAMP_LEN) == 0 ||
@@ skipping 15 matching lines @@
 static SkImageDecoder_DecodeReg gReg(sk_libgif_dfactory);
 
 static SkImageDecoder::Format get_format_gif(SkStreamRewindable* stream) {
     if (is_gif(stream)) {
         return SkImageDecoder::kGIF_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_gif);