Rename GIFImageReader to SkGifImageReader

src/codec/SkGifCodec.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.
  */
 
 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
@@ skipping 54 matching lines @@
     SkCodecPrintf("Gif Error: %s\n", msg);
     return result;
 }
 
 /*
  * Assumes IsGif was called and returned true
  * Creates a gif decoder
  * Reads enough of the stream to determine the image format
  */
 SkCodec* SkGifCodec::NewFromStream(SkStream* stream) {
-    std::unique_ptr<GIFImageReader> reader(new GIFImageReader(stream));
-    if (!reader->parse(GIFImageReader::GIFSizeQuery)) {
+    std::unique_ptr<SkGifImageReader> reader(new SkGifImageReader(stream));
+    if (!reader->parse(SkGifImageReader::GIFSizeQuery)) {
         // Not enough data to determine the size.
         return nullptr;
     }
 
     if (0 == reader->screenWidth() || 0 == reader->screenHeight()) {
         return nullptr;
     }
 
     const auto alpha = reader->firstFrameHasAlpha() ? SkEncodedInfo::kBinary_Alpha
                                                     : SkEncodedInfo::kOpaque_Alpha;
@@ skipping 16 matching lines @@
                                              colorType, alphaType);
     return new SkGifCodec(encodedInfo, imageInfo, reader.release());
 }
 
 bool SkGifCodec::onRewind() {
     fReader->clearDecodeState();
     return true;
 }
 
 SkGifCodec::SkGifCodec(const SkEncodedInfo& encodedInfo, const SkImageInfo& imageInfo,
-                       GIFImageReader* reader)
+                       SkGifImageReader* reader)
     : INHERITED(encodedInfo, imageInfo, nullptr)
     , fReader(reader)
     , fTmpBuffer(nullptr)
     , fSwizzler(nullptr)
     , fCurrColorTable(nullptr)
     , fCurrColorTableIsReal(false)
     , fFilledBackground(false)
     , fFirstCallToIncrementalDecode(false)
     , fDst(nullptr)
     , fDstRowBytes(0)
     , fRowsDecoded(0)
 {
     reader->setClient(this);
 }
 
 std::vector<SkCodec::FrameInfo> SkGifCodec::onGetFrameInfo() {
-    fReader->parse(GIFImageReader::GIFFrameCountQuery);
+    fReader->parse(SkGifImageReader::GIFFrameCountQuery);
     const size_t size = fReader->imagesCount();
     std::vector<FrameInfo> result(size);
     for (size_t i = 0; i < size; i++) {
         const GIFFrameContext* frameContext = fReader->frameContext(i);
         result[i].fDuration = frameContext->delayTime();
         result[i].fRequiredFrame = frameContext->getRequiredFrame();
     }
     return result;
 }
 
@@ skipping 36 matching lines @@
         // FIXME: It is possible that a later frame can be decoded to index8, if it does one of the
         // following:
         // - Covers the entire previous frame
         // - Shares a color table (and transparent index) with any prior frames that are showing.
         // We must support index8 for the first frame to be backwards compatible on Android, but
         // we do not (currently) need to support later frames as index8.
         return gif_error("Cannot decode multiframe gif (except frame 0) as index 8.\n",
                          kInvalidConversion);
     }
 
-    fReader->parse((GIFImageReader::GIFParseQuery) frameIndex);
+    fReader->parse((SkGifImageReader::GIFParseQuery) frameIndex);
 
     if (frameIndex >= fReader->imagesCount()) {
         return gif_error("frame index out of range!\n", kIncompleteInput);
     }
 
     fTmpBuffer.reset(new uint8_t[dstInfo.minRowBytes()]);
 
     // Initialize color table and copy to the client if necessary
     this->initializeColorTable(dstInfo, frameIndex, inputColorPtr, inputColorCount);
     this->initializeSwizzler(dstInfo, frameIndex);
@@ skipping 64 matching lines @@
 
     fFirstCallToIncrementalDecode = true;
 
     return kSuccess;
 }
 
 SkCodec::Result SkGifCodec::onIncrementalDecode(int* rowsDecoded) {
     // It is possible the client has appended more data. Parse, if needed.
     const auto& options = this->options();
     const size_t frameIndex = options.fFrameIndex;
-    fReader->parse((GIFImageReader::GIFParseQuery) frameIndex);
+    fReader->parse((SkGifImageReader::GIFParseQuery) frameIndex);
 
     const bool firstCallToIncrementalDecode = fFirstCallToIncrementalDecode;
     fFirstCallToIncrementalDecode = false;
     return this->decodeFrame(firstCallToIncrementalDecode, options, rowsDecoded);
 }
 
 SkCodec::Result SkGifCodec::decodeFrame(bool firstAttempt, const Options& opts, int* rowsDecoded) {
     const SkImageInfo& dstInfo = this->dstInfo();
     const size_t frameIndex = opts.fFrameIndex;
     SkASSERT(frameIndex < fReader->imagesCount());
@@ skipping 67 matching lines @@
         fFilledBackground = filledBackground;
         if (filledBackground) {
             // Report the full (scaled) height, since the client will never need to fill.
             fRowsDecoded = get_scaled_dimension(dstInfo.height(), fSwizzler->sampleY());
         } else {
             // This will be updated by haveDecodedRow.
             fRowsDecoded = 0;
         }
     }
 
-    // Note: there is a difference between the following call to GIFImageReader::decode
+    // Note: there is a difference between the following call to SkGifImageReader::decode
     // returning false and leaving frameDecoded false:
     // - If the method returns false, there was an error in the stream. We still treat this as
     //   incomplete, since we have already decoded some rows.
     // - If frameDecoded is false, that just means that we do not have enough data. If more data
     //   is supplied, we may be able to continue decoding this frame. We also treat this as
     //   incomplete.
     // FIXME: Ensure that we do not attempt to continue decoding if the method returns false and
     // more data is supplied.
     bool frameDecoded = false;
     if (!fReader->decode(frameIndex, &frameDecoded) || !frameDecoded) {
@@ skipping 183 matching lines @@
         void* copiedLine = SkTAddOffset<void>(dstLine, fSwizzler->swizzleOffsetBytes());
         void* dst = copiedLine;
         for (unsigned i = 1; i < repeatCount; i++) {
             dst = SkTAddOffset<void>(dst, fDstRowBytes);
             memcpy(dst, copiedLine, bytesToCopy);
         }
     }
 
     return true;
 }