Fix more namespace conflicts in 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 55 matching lines @@
     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<SkGifImageReader> reader(new SkGifImageReader(stream));
-    if (!reader->parse(SkGifImageReader::GIFSizeQuery)) {
+    if (!reader->parse(SkGifImageReader::SkGIFSizeQuery)) {
         // 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 33 matching lines @@
     , fFilledBackground(false)
     , fFirstCallToIncrementalDecode(false)
     , fDst(nullptr)
     , fDstRowBytes(0)
     , fRowsDecoded(0)
 {
     reader->setClient(this);
 }
 
 std::vector<SkCodec::FrameInfo> SkGifCodec::onGetFrameInfo() {
-    fReader->parse(SkGifImageReader::GIFFrameCountQuery);
+    fReader->parse(SkGifImageReader::SkGIFFrameCountQuery);
     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);
+        const SkGIFFrameContext* frameContext = fReader->frameContext(i);
         result[i].fDuration = frameContext->delayTime();
         result[i].fRequiredFrame = frameContext->getRequiredFrame();
     }
     return result;
 }
 
 void SkGifCodec::initializeColorTable(const SkImageInfo& dstInfo, size_t frameIndex,
         SkPMColor* inputColorPtr, int* inputColorCount) {
     fCurrColorTable = fReader->getColorTable(dstInfo.colorType(), frameIndex);
     fCurrColorTableIsReal = fCurrColorTable;
@@ skipping 32 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((SkGifImageReader::GIFParseQuery) frameIndex);
+    fReader->parse((SkGifImageReader::SkGIFParseQuery) 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);
     return kSuccess;
 }
 
 void SkGifCodec::initializeSwizzler(const SkImageInfo& dstInfo, size_t frameIndex) {
-    const GIFFrameContext* frame = fReader->frameContext(frameIndex);
+    const SkGIFFrameContext* frame = fReader->frameContext(frameIndex);
     // This is only called by prepareToDecode, which ensures frameIndex is in range.
     SkASSERT(frame);
 
     const int xBegin = frame->xOffset();
     const int xEnd = std::min(static_cast<int>(frame->xOffset() + frame->width()),
                               static_cast<int>(fReader->screenWidth()));
 
     // CreateSwizzler only reads left and right of the frame. We cannot use the frame's raw
     // frameRect, since it might extend beyond the edge of the frame.
     SkIRect swizzleRect = SkIRect::MakeLTRB(xBegin, 0, xEnd, 0);
@@ skipping 49 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((SkGifImageReader::GIFParseQuery) frameIndex);
+    fReader->parse((SkGifImageReader::SkGIFParseQuery) 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());
-    const GIFFrameContext* frameContext = fReader->frameContext(frameIndex);
+    const SkGIFFrameContext* frameContext = fReader->frameContext(frameIndex);
     if (firstAttempt) {
         // rowsDecoded reports how many rows have been initialized, so a layer above
         // can fill the rest. In some cases, we fill the background before decoding
         // (or it is already filled for us), so we report rowsDecoded to be the full
         // height.
         bool filledBackground = false;
         if (frameContext->getRequiredFrame() == kNone) {
             // We may need to clear to transparent for one of the following reasons:
             // - The frameRect does not cover the full bounds. haveDecodedRow will
             //   only draw inside the frameRect, so we need to clear the rest.
             // - There is a valid transparent pixel value. (FIXME: I'm assuming
             //   writeTransparentPixels will be false in this case, based on
             //   Chromium's assumption that it would already be zeroed. If we
             //   change that behavior, could we skip Filling here?)
             // - The frame is interlaced. There is no obvious way to fill
             //   afterwards for an incomplete image. (FIXME: Does the first pass
             //   cover all rows? If so, we do not have to fill here.)
             if (frameContext->frameRect() != this->getInfo().bounds()
-                    || frameContext->transparentPixel() < MAX_COLORS
+                    || frameContext->transparentPixel() < SK_MAX_COLORS
                     || frameContext->interlaced()) {
                 // fill ignores the width (replaces it with the actual, scaled width).
                 // But we need to scale in Y.
                 const int scaledHeight = get_scaled_dimension(dstInfo.height(),
                                                               fSwizzler->sampleY());
                 auto fillInfo = dstInfo.makeWH(0, scaledHeight);
                 fSwizzler->fill(fillInfo, fDst, fDstRowBytes, this->getFillValue(dstInfo),
                                 opts.fZeroInitialized);
                 filledBackground = true;
             }
@@ skipping 86 matching lines @@
     // which ignores the background color.
     // If the colorType is kIndex_8, and there was no color table (i.e.
     // fCurrColorTableIsReal is false), this value (zero) corresponds to the
     // only entry in the dummy color table provided to the client.
     return SK_ColorTRANSPARENT;
 }
 
 bool SkGifCodec::haveDecodedRow(size_t frameIndex, const unsigned char* rowBegin,
                                 size_t rowNumber, unsigned repeatCount, bool writeTransparentPixels)
 {
-    const GIFFrameContext* frameContext = fReader->frameContext(frameIndex);
+    const SkGIFFrameContext* frameContext = fReader->frameContext(frameIndex);
     // The pixel data and coordinates supplied to us are relative to the frame's
     // origin within the entire image size, i.e.
     // (frameContext->xOffset, frameContext->yOffset). There is no guarantee
     // that width == (size().width() - frameContext->xOffset), so
     // we must ensure we don't run off the end of either the source data or the
     // row's X-coordinates.
     const size_t width = frameContext->width();
     const int xBegin = frameContext->xOffset();
     const int yBegin = frameContext->yOffset() + rowNumber;
     const int xEnd = std::min(static_cast<int>(frameContext->xOffset() + width),
@@ skipping 134 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;
 }