Fix more namespace conflicts in SkGifImageReader

third_party/gif/SkGifImageReader.h

 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
@@ skipping 35 matching lines @@
 #include "SkCodecPriv.h"
 #include "SkCodecAnimation.h"
 #include "SkColorTable.h"
 #include "SkData.h"
 #include "SkImageInfo.h"
 #include "SkStreamBuffer.h"
 #include "../private/SkTArray.h"
 #include <memory>
 #include <vector>
 
-typedef SkTArray<unsigned char, true> GIFRow;
+typedef SkTArray<unsigned char, true> SkGIFRow;
 
 
-#define MAX_DICTIONARY_ENTRY_BITS 12
-#define MAX_DICTIONARY_ENTRIES    4096 // 2^MAX_DICTIONARY_ENTRY_BITS
-#define MAX_COLORS                256
-#define BYTES_PER_COLORMAP_ENTRY  3
-
-constexpr int cLoopCountNotSeen = -2;
-constexpr size_t kNotFound = static_cast<size_t>(-1);
+#define SK_MAX_DICTIONARY_ENTRY_BITS 12
+#define SK_MAX_DICTIONARY_ENTRIES    4096 // 2^SK_MAX_DICTIONARY_ENTRY_BITS
+#define SK_MAX_COLORS                256
+#define SK_BYTES_PER_COLORMAP_ENTRY  3
 
 // List of possible parsing states.
-enum GIFState {
-    GIFType,
-    GIFGlobalHeader,
-    GIFGlobalColormap,
-    GIFImageStart,
-    GIFImageHeader,
-    GIFImageColormap,
-    GIFImageBody,
-    GIFLZWStart,
-    GIFLZW,
-    GIFSubBlock,
-    GIFExtension,
-    GIFControlExtension,
-    GIFConsumeBlock,
-    GIFSkipBlock,
-    GIFDone,
-    GIFCommentExtension,
-    GIFApplicationExtension,
-    GIFNetscapeExtensionBlock,
-    GIFConsumeNetscapeExtension,
-    GIFConsumeComment
+enum SkGIFState {
+    SkGIFType,
+    SkGIFGlobalHeader,
+    SkGIFGlobalColormap,
+    SkGIFImageStart,
+    SkGIFImageHeader,
+    SkGIFImageColormap,
+    SkGIFImageBody,
+    SkGIFLZWStart,
+    SkGIFLZW,
+    SkGIFSubBlock,
+    SkGIFExtension,
+    SkGIFControlExtension,
+    SkGIFConsumeBlock,
+    SkGIFSkipBlock,
+    SkGIFDone,
+    SkGIFCommentExtension,
+    SkGIFApplicationExtension,
+    SkGIFNetscapeExtensionBlock,
+    SkGIFConsumeNetscapeExtension,
+    SkGIFConsumeComment
 };
 
-struct GIFFrameContext;
+struct SkGIFFrameContext;
 
 // LZW decoder state machine.
-class GIFLZWContext final : public SkNoncopyable {
+class SkGIFLZWContext final : public SkNoncopyable {
 public:
-    GIFLZWContext(SkGifCodec* client, const GIFFrameContext* frameContext)
+    SkGIFLZWContext(SkGifCodec* client, const SkGIFFrameContext* frameContext)
         : codesize(0)
         , codemask(0)
         , clearCode(0)
         , avail(0)
         , oldcode(0)
         , firstchar(0)
         , bits(0)
         , datum(0)
         , ipass(0)
         , irow(0)
@@ skipping 15 matching lines @@
     int clearCode; // Codeword used to trigger dictionary reset.
     int avail; // Index of next available slot in dictionary.
     int oldcode;
     unsigned char firstchar;
     int bits; // Number of unread bits in "datum".
     int datum; // 32-bit input buffer.
     int ipass; // Interlace pass; Ranges 1-4 if interlaced.
     size_t irow; // Current output row, starting at zero.
     size_t rowsRemaining; // Rows remaining to be output.
 
-    unsigned short prefix[MAX_DICTIONARY_ENTRIES];
-    unsigned char suffix[MAX_DICTIONARY_ENTRIES];
-    unsigned short suffixLength[MAX_DICTIONARY_ENTRIES];
-    GIFRow rowBuffer; // Single scanline temporary buffer.
+    unsigned short prefix[SK_MAX_DICTIONARY_ENTRIES];
+    unsigned char suffix[SK_MAX_DICTIONARY_ENTRIES];
+    unsigned short suffixLength[SK_MAX_DICTIONARY_ENTRIES];
+    SkGIFRow rowBuffer; // Single scanline temporary buffer.
     unsigned char* rowIter;
 
     SkGifCodec* const m_client;
-    const GIFFrameContext* m_frameContext;
+    const SkGIFFrameContext* m_frameContext;
 };
 
-class GIFColorMap final {
+class SkGIFColorMap final {
 public:
-    GIFColorMap()
+    SkGIFColorMap()
         : m_isDefined(false)
         , m_colors(0)
         , m_packColorProc(nullptr)
     {
     }
 
     void setNumColors(size_t colors) {
         m_colors = colors;
     }
 
     size_t numColors() const { return m_colors; }
 
     void setRawData(const char* data, size_t size)
     {
         // FIXME: Can we avoid this copy?
         m_rawData = SkData::MakeWithCopy(data, size);
-        SkASSERT(m_colors * BYTES_PER_COLORMAP_ENTRY == size);
+        SkASSERT(m_colors * SK_BYTES_PER_COLORMAP_ENTRY == size);
         m_isDefined = true;
     }
     bool isDefined() const { return m_isDefined; }
 
     // Build RGBA table using the data stream.
     sk_sp<SkColorTable> buildTable(SkColorType dstColorType, size_t transparentPixel) const;
 
 private:
     bool m_isDefined;
     size_t m_colors;
     sk_sp<SkData> m_rawData;
     mutable PackColorProc m_packColorProc;
     mutable sk_sp<SkColorTable> m_table;
 };
 
 // LocalFrame output state machine.
-struct GIFFrameContext : SkNoncopyable {
+struct SkGIFFrameContext : SkNoncopyable {
 public:
-    GIFFrameContext(int id)
+    SkGIFFrameContext(int id)
         : m_frameId(id)
         , m_xOffset(0)
         , m_yOffset(0)
         , m_width(0)
         , m_height(0)
         , m_transparentPixel(kNotFound)
         , m_disposalMethod(SkCodecAnimation::Keep_DisposalMethod)
         , m_requiredFrame(SkCodec::kNone)
         , m_dataSize(0)
         , m_progressiveDisplay(false)
         , m_interlaced(false)
         , m_delayTime(0)
         , m_currentLzwBlock(0)
         , m_isComplete(false)
         , m_isHeaderDefined(false)
         , m_isDataSizeDefined(false)
     {
     }
 
-    ~GIFFrameContext()
+    static constexpr size_t kNotFound = static_cast<size_t>(-1);
+
+    ~SkGIFFrameContext()
     {
     }
 
     void addLzwBlock(const void* data, size_t size)
     {
         m_lzwBlocks.push_back(SkData::MakeWithCopy(data, size));
     }
 
     bool decode(SkGifCodec* client, bool* frameDecoded);
 
@@ skipping 28 matching lines @@
     {
         m_dataSize = size;
         m_isDataSizeDefined = true;
     }
     bool progressiveDisplay() const { return m_progressiveDisplay; }
     void setProgressiveDisplay(bool progressiveDisplay) { m_progressiveDisplay = progressiveDisplay; }
     bool interlaced() const { return m_interlaced; }
     void setInterlaced(bool interlaced) { m_interlaced = interlaced; }
 
     void clearDecodeState() { m_lzwContext.reset(); }
-    const GIFColorMap& localColorMap() const { return m_localColorMap; }
-    GIFColorMap& localColorMap() { return m_localColorMap; }
+    const SkGIFColorMap& localColorMap() const { return m_localColorMap; }
+    SkGIFColorMap& localColorMap() { return m_localColorMap; }
 
 private:
     int m_frameId;
     unsigned m_xOffset;
     unsigned m_yOffset; // With respect to "screen" origin.
     unsigned m_width;
     unsigned m_height;
     size_t m_transparentPixel; // Index of transparent pixel. Value is kNotFound if there is no transparent pixel.
     SkCodecAnimation::DisposalMethod m_disposalMethod; // Restore to background, leave in place, etc.
     size_t m_requiredFrame;
     int m_dataSize;
 
     bool m_progressiveDisplay; // If true, do Haeberli interlace hack.
     bool m_interlaced; // True, if scanlines arrive interlaced order.
 
     unsigned m_delayTime; // Display time, in milliseconds, for this image in a multi-image GIF.
 
-    std::unique_ptr<GIFLZWContext> m_lzwContext;
+    std::unique_ptr<SkGIFLZWContext> m_lzwContext;
     std::vector<sk_sp<SkData>> m_lzwBlocks; // LZW blocks for this frame.
-    GIFColorMap m_localColorMap;
+    SkGIFColorMap m_localColorMap;
 
     size_t m_currentLzwBlock;
     bool m_isComplete;
     bool m_isHeaderDefined;
     bool m_isDataSizeDefined;
 };
 
 class SkGifImageReader final : public SkNoncopyable {
 public:
     // This takes ownership of stream.
     SkGifImageReader(SkStream* stream)
         : m_client(nullptr)
-        , m_state(GIFType)
+        , m_state(SkGIFType)
         , m_bytesToConsume(6) // Number of bytes for GIF type, either "GIF87a" or "GIF89a".
         , m_version(0)
         , m_screenWidth(0)
         , m_screenHeight(0)
         , m_loopCount(cLoopCountNotSeen)
         , m_streamBuffer(stream)
         , m_parseCompleted(false)
         , m_firstFrameHasAlpha(false)
         , m_firstFrameSupportsIndex8(false)
     {
     }
 
+    static constexpr int cLoopCountNotSeen = -2;
+
     ~SkGifImageReader()
     {
     }
 
     void setClient(SkGifCodec* client) { m_client = client; }
 
     unsigned screenWidth() const { return m_screenWidth; }
     unsigned screenHeight() const { return m_screenHeight; }
 
     // Option to pass to parse(). All enums are negative, because a non-negative value is used to
     // indicate that the Reader should parse up to and including the frame indicated.
-    enum GIFParseQuery {
+    enum SkGIFParseQuery {
         // Parse enough to determine the size. Note that this parses the first frame's header,
         // since we may decide to expand based on the frame's dimensions.
-        GIFSizeQuery        = -1,
+        SkGIFSizeQuery        = -1,
         // Parse to the end, so we know about all frames.
-        GIFFrameCountQuery  = -2,
+        SkGIFFrameCountQuery  = -2,
     };
 
     // Parse incoming GIF data stream into internal data structures.
     // Non-negative values are used to indicate to parse through that frame.
     // Return true if parsing has progressed or there is not enough data.
     // Return false if a fatal error is encountered.
-    bool parse(GIFParseQuery);
+    bool parse(SkGIFParseQuery);
 
     // Decode the frame indicated by frameIndex.
     // frameComplete will be set to true if the frame is completely decoded.
     // The method returns false if there is an error.
     bool decode(size_t frameIndex, bool* frameComplete);
 
     size_t imagesCount() const
     {
         if (m_frames.empty())
             return 0;
 
         // This avoids counting an empty frame when the file is truncated right after
-        // GIFControlExtension but before GIFImageHeader.
+        // SkGIFControlExtension but before SkGIFImageHeader.
         // FIXME: This extra complexity is not necessary and we should just report m_frames.size().
         return m_frames.back()->isHeaderDefined() ? m_frames.size() : m_frames.size() - 1;
     }
     int loopCount() const { return m_loopCount; }
 
-    const GIFColorMap& globalColorMap() const
+    const SkGIFColorMap& globalColorMap() const
     {
         return m_globalColorMap;
     }
 
-    const GIFFrameContext* frameContext(size_t index) const
+    const SkGIFFrameContext* frameContext(size_t index) const
     {
         return index < m_frames.size() ? m_frames[index].get() : 0;
     }
 
     void clearDecodeState() {
         for (size_t index = 0; index < m_frames.size(); index++) {
             m_frames[index]->clearDecodeState();
         }
     }
 
@@ skipping 13 matching lines @@
     void addFrameIfNecessary();
     bool currentFrameIsFirstFrame() const
     {
         return m_frames.empty() || (m_frames.size() == 1u && !m_frames[0]->isComplete());
     }
 
     // Unowned pointer
     SkGifCodec* m_client;
 
     // Parsing state machine.
-    GIFState m_state; // Current decoder master state.
+    SkGIFState m_state; // Current decoder master state.
     size_t m_bytesToConsume; // Number of bytes to consume for next stage of parsing.
 
     // Global (multi-image) state.
     int m_version; // Either 89 for GIF89 or 87 for GIF87.
     unsigned m_screenWidth; // Logical screen width & height.
     unsigned m_screenHeight;
-    GIFColorMap m_globalColorMap;
+    SkGIFColorMap m_globalColorMap;
     int m_loopCount; // Netscape specific extension block to control the number of animation loops a GIF renders.
 
-    std::vector<std::unique_ptr<GIFFrameContext>> m_frames;
+    std::vector<std::unique_ptr<SkGIFFrameContext>> m_frames;
 
     SkStreamBuffer m_streamBuffer;
     bool m_parseCompleted;
 
-    // These values can be computed before we create a GIFFrameContext, so we
+    // These values can be computed before we create a SkGIFFrameContext, so we
     // store them here instead of on m_frames[0].
     bool m_firstFrameHasAlpha;
     bool m_firstFrameSupportsIndex8;
 };
 
 #endif