Remove SkImageGenerator pieces only for SkCodec.

src/images/SkDecodingImageGenerator.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkImageDecoder.h"
@@ skipping 20 matching lines @@
     const bool                          fDitherImage;
 
     DecodingImageGenerator(SkData* data,
                            SkStreamRewindable* stream,
                            const SkImageInfo& info,
                            int sampleSize,
                            bool ditherImage);
 
 protected:
     SkData* onRefEncodedData() override;
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
     Result onGetPixels(const SkImageInfo& info,
                        void* pixels, size_t rowBytes, const Options&,
                        SkPMColor ctable[], int* ctableCount) override;
+#else
+    bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
+                     SkPMColor ctable[], int* ctableCount) override;
+#endif
     bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
                          SkYUVColorSpace* colorSpace) override;
 
 private:
     typedef SkImageGenerator INHERITED;
 };
 
 /**
  *  Special allocator used by getPixels(). Uses preallocated memory
  *  provided if possible, else fall-back on the default allocator
@@ skipping 83 matching lines @@
             return NULL;
         }
         size_t length = fStream->getLength();
         if (length) {
             fData = SkData::NewFromStream(fStream, length);
         }
     }
     return SkSafeRef(fData);
 }
 
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
 SkImageGenerator::Result DecodingImageGenerator::onGetPixels(const SkImageInfo& info,
         void* pixels, size_t rowBytes, const Options& options, SkPMColor ctableEntries[],
         int* ctableCount) {
+#else
+bool DecodingImageGenerator::onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
+                                         SkPMColor ctableEntries[], int* ctableCount) {
+#endif
     if (fInfo != info) {
         // The caller has specified a different info.  This is an
         // error for this kind of SkImageGenerator.  Use the Options
         // to change the settings.
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
         if (info.dimensions() != fInfo.dimensions()) {
             return kInvalidScale;
         }
         return kInvalidConversion;
+#else
+        return false;
+#endif
     }
 
     SkAssertResult(fStream->rewind());
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(fStream));
     if (NULL == decoder.get()) {
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
         return kInvalidInput;
+#else
+        return false;
+#endif
     }
     decoder->setDitherImage(fDitherImage);
     decoder->setSampleSize(fSampleSize);
     decoder->setRequireUnpremultipliedColors(info.alphaType() == kUnpremul_SkAlphaType);
 
     SkBitmap bitmap;
     TargetAllocator allocator(fInfo, pixels, rowBytes);
     decoder->setAllocator(&allocator);
     const SkImageDecoder::Result decodeResult = decoder->decode(fStream, &bitmap, info.colorType(),
                                                                 SkImageDecoder::kDecodePixels_Mode);
     decoder->setAllocator(NULL);
     if (SkImageDecoder::kFailure == decodeResult) {
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
         return kInvalidInput;
+#else
+        return false;
+#endif
     }
     if (allocator.isReady()) {  // Did not use pixels!
         SkBitmap bm;
         SkASSERT(bitmap.canCopyTo(info.colorType()));
         bool copySuccess = bitmap.copyTo(&bm, info.colorType(), &allocator);
         if (!copySuccess || allocator.isReady()) {
             SkDEBUGFAIL("bitmap.copyTo(requestedConfig) failed.");
             // Earlier we checked canCopyto(); we expect consistency.
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
             return kInvalidConversion;
+#else
+            return false;
+#endif
         }
         SkASSERT(check_alpha(info.alphaType(), bm.alphaType()));
     } else {
         SkASSERT(check_alpha(info.alphaType(), bitmap.alphaType()));
     }
 
     if (kIndex_8_SkColorType == info.colorType()) {
         if (kIndex_8_SkColorType != bitmap.colorType()) {
             // they asked for Index8, but we didn't receive that from decoder
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
             return kInvalidConversion;
+#else
+            return false;
+#endif
         }
         SkColorTable* ctable = bitmap.getColorTable();
         if (NULL == ctable) {
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
             return kInvalidConversion;
+#else
+            return false;
+#endif
         }
         const int count = ctable->count();
         memcpy(ctableEntries, ctable->readColors(), count * sizeof(SkPMColor));
         *ctableCount = count;
     }
+#ifdef SK_LEGACY_IMAGE_GENERATOR_ENUMS_AND_OPTIONS
     if (SkImageDecoder::kPartialSuccess == decodeResult) {
         return kIncompleteInput;
     }
     return kSuccess;
+#else
+    return true;
+#endif
 }
 
 bool DecodingImageGenerator::onGetYUV8Planes(SkISize sizes[3], void* planes[3],
                                              size_t rowBytes[3], SkYUVColorSpace* colorSpace) {
     if (!fStream->rewind()) {
         return false;
     }
 
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(fStream));
     if (NULL == decoder.get()) {
@@ skipping 69 matching lines @@
 
 SkImageGenerator* SkDecodingImageGenerator::Create(
         SkStreamRewindable* stream,
         const SkDecodingImageGenerator::Options& opts) {
     SkASSERT(stream != NULL);
     if (stream == NULL) {
         return NULL;
     }
     return CreateDecodingImageGenerator(NULL, stream, opts);
 }