Rename enums/functions that collide in chromium style in platform/

third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 108 matching lines @@
 
     const GIFColorMap::Table& colorTable = frameContext->localColorMap().isDefined() ? frameContext->localColorMap().table() : m_reader->globalColorMap().table();
 
     if (colorTable.isEmpty())
         return true;
 
     GIFColorMap::Table::const_iterator colorTableIter = colorTable.begin();
 
     // Initialize the frame if necessary.
     ImageFrame& buffer = m_frameBufferCache[frameIndex];
-    if ((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
+    if ((buffer.getStatus() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
         return false;
 
     const size_t transparentPixel = frameContext->transparentPixel();
     GIFRow::const_iterator rowEnd = rowBegin + (xEnd - xBegin);
     ImageFrame::PixelData* currentAddress = buffer.getAddr(xBegin, yBegin);
 
     // We may or may not need to write transparent pixels to the buffer.
     // If we're compositing against a previous image, it's wrong, and if
     // we're writing atop a cleared, fully transparent buffer, it's
     // unnecessary; but if we're decoding an interlaced gif and
@@ skipping 36 matching lines @@
 bool GIFImageDecoder::parseCompleted() const
 {
     return m_reader && m_reader->parseCompleted();
 }
 
 bool GIFImageDecoder::frameComplete(size_t frameIndex)
 {
     // Initialize the frame if necessary.  Some GIFs insert do-nothing frames,
     // in which case we never reach haveDecodedRow() before getting here.
     ImageFrame& buffer = m_frameBufferCache[frameIndex];
-    if ((buffer.status() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
+    if ((buffer.getStatus() == ImageFrame::FrameEmpty) && !initFrameBuffer(frameIndex))
         return false; // initFrameBuffer() has already called setFailed().
 
     buffer.setStatus(ImageFrame::FrameComplete);
 
     if (!m_currentBufferSawAlpha) {
         // The whole frame was non-transparent, so it's possible that the entire
         // resulting buffer was non-transparent, and we can setHasAlpha(false).
         if (buffer.originalFrameRect().contains(IntRect(IntPoint(), size()))) {
             buffer.setHasAlpha(false);
             buffer.setRequiredPreviousFrameIndex(kNotFound);
         } else if (buffer.requiredPreviousFrameIndex() != kNotFound) {
             // Tricky case.  This frame does not have alpha only if everywhere
             // outside its rect doesn't have alpha.  To know whether this is
             // true, we check the start state of the frame -- if it doesn't have
             // alpha, we're safe.
             const ImageFrame* prevBuffer = &m_frameBufferCache[buffer.requiredPreviousFrameIndex()];
-            ASSERT(prevBuffer->disposalMethod() != ImageFrame::DisposeOverwritePrevious);
+            ASSERT(prevBuffer->getDisposalMethod() != ImageFrame::DisposeOverwritePrevious);
 
             // Now, if we're at a DisposeNotSpecified or DisposeKeep frame, then
             // we can say we have no alpha if that frame had no alpha.  But
             // since in initFrameBuffer() we already copied that frame's alpha
             // state into the current frame's, we need do nothing at all here.
             //
             // The only remaining case is a DisposeOverwriteBgcolor frame.  If
             // it had no alpha, and its rect is contained in the current frame's
             // rect, we know the current frame has no alpha.
-            if ((prevBuffer->disposalMethod() == ImageFrame::DisposeOverwriteBgcolor) && !prevBuffer->hasAlpha() && buffer.originalFrameRect().contains(prevBuffer->originalFrameRect()))
+            if ((prevBuffer->getDisposalMethod() == ImageFrame::DisposeOverwriteBgcolor) && !prevBuffer->hasAlpha() && buffer.originalFrameRect().contains(prevBuffer->originalFrameRect()))
                 buffer.setHasAlpha(false);
         }
     }
 
     return true;
 }
 
 size_t GIFImageDecoder::clearCacheExceptFrame(size_t clearExceptFrame)
 {
     // We expect that after this call, we'll be asked to decode frames after
     // this one.  So we want to avoid clearing frames such that those requests
     // would force re-decoding from the beginning of the image.
     //
     // When |clearExceptFrame| is e.g. DisposeKeep, simply not clearing that
     // frame is sufficient, as the next frame will be based on it, and in
     // general future frames can't be based on anything previous.
     //
     // However, if this frame is DisposeOverwritePrevious, then subsequent
     // frames will depend on this frame's required previous frame.  In this
     // case, we need to preserve both this frame and that one.
     size_t clearExceptFrame2 = kNotFound;
     if (clearExceptFrame < m_frameBufferCache.size()) {
         const ImageFrame& frame = m_frameBufferCache[clearExceptFrame];
-        if ((frame.status() != ImageFrame::FrameEmpty) && (frame.disposalMethod() == ImageFrame::DisposeOverwritePrevious)) {
+        if ((frame.getStatus() != ImageFrame::FrameEmpty) && (frame.getDisposalMethod() == ImageFrame::DisposeOverwritePrevious)) {
             clearExceptFrame2 = clearExceptFrame;
             clearExceptFrame = frame.requiredPreviousFrameIndex();
         }
     }
 
     // Now |clearExceptFrame| indicates the frame that future frames will
     // depend on.  But if decoding is skipping forward past intermediate frames,
     // this frame may be FrameEmpty.  So we need to keep traversing back through
     // the required previous frames until we find the nearest non-empty
     // ancestor.  Preserving that will minimize the amount of future decoding
     // needed.
-    while ((clearExceptFrame < m_frameBufferCache.size()) && (m_frameBufferCache[clearExceptFrame].status() == ImageFrame::FrameEmpty))
+    while ((clearExceptFrame < m_frameBufferCache.size()) && (m_frameBufferCache[clearExceptFrame].getStatus() == ImageFrame::FrameEmpty))
         clearExceptFrame = m_frameBufferCache[clearExceptFrame].requiredPreviousFrameIndex();
     return clearCacheExceptTwoFrames(clearExceptFrame, clearExceptFrame2);
 }
 
 
 size_t GIFImageDecoder::clearCacheExceptTwoFrames(size_t clearExceptFrame1, size_t clearExceptFrame2)
 {
     size_t frameBytesCleared = 0;
     for (size_t i = 0; i < m_frameBufferCache.size(); ++i) {
-        if (m_frameBufferCache[i].status() != ImageFrame::FrameEmpty && i != clearExceptFrame1 && i != clearExceptFrame2) {
+        if (m_frameBufferCache[i].getStatus() != ImageFrame::FrameEmpty && i != clearExceptFrame1 && i != clearExceptFrame2) {
             frameBytesCleared += frameBytesAtIndex(i);
             clearFrameBuffer(i);
         }
     }
     return frameBytesCleared;
 }
 
 void GIFImageDecoder::clearFrameBuffer(size_t frameIndex)
 {
-    if (m_reader && m_frameBufferCache[frameIndex].status() == ImageFrame::FramePartial) {
+    if (m_reader && m_frameBufferCache[frameIndex].getStatus() == ImageFrame::FramePartial) {
         // Reset the state of the partial frame in the reader so that the frame
         // can be decoded again when requested.
         m_reader->clearDecodeState(frameIndex);
     }
     ImageDecoder::clearFrameBuffer(frameIndex);
 }
 
 size_t GIFImageDecoder::decodeFrameCount()
 {
     parse(GIFFrameCountQuery);
     // If decoding fails, |m_reader| will have been destroyed.  Instead of
     // returning 0 in this case, return the existing number of frames.  This way
     // if we get halfway through the image before decoding fails, we won't
     // suddenly start reporting that the image has zero frames.
     return failed() ? m_frameBufferCache.size() : m_reader->imagesCount();
 }
 
 void GIFImageDecoder::initializeNewFrame(size_t index)
 {
     ImageFrame* buffer = &m_frameBufferCache[index];
     const GIFFrameContext* frameContext = m_reader->frameContext(index);
     buffer->setOriginalFrameRect(intersection(frameContext->frameRect(), IntRect(IntPoint(), size())));
     buffer->setDuration(frameContext->delayTime());
-    buffer->setDisposalMethod(frameContext->disposalMethod());
+    buffer->setDisposalMethod(frameContext->getDisposalMethod());
     buffer->setRequiredPreviousFrameIndex(findRequiredPreviousFrame(index, false));
 }
 
 void GIFImageDecoder::decode(size_t index)
 {
     parse(GIFFrameCountQuery);
 
     if (failed())
         return;
 
     Vector<size_t> framesToDecode;
     size_t frameToDecode = index;
     do {
         framesToDecode.append(frameToDecode);
         frameToDecode = m_frameBufferCache[frameToDecode].requiredPreviousFrameIndex();
-    } while (frameToDecode != kNotFound && m_frameBufferCache[frameToDecode].status() != ImageFrame::FrameComplete);
+    } while (frameToDecode != kNotFound && m_frameBufferCache[frameToDecode].getStatus() != ImageFrame::FrameComplete);
 
     for (auto i = framesToDecode.rbegin(); i != framesToDecode.rend(); ++i) {
         if (!m_reader->decode(*i)) {
             setFailed();
             return;
         }
 
         // We need more data to continue decoding.
-        if (m_frameBufferCache[*i].status() != ImageFrame::FrameComplete)
+        if (m_frameBufferCache[*i].getStatus() != ImageFrame::FrameComplete)
             break;
     }
 
     // It is also a fatal error if all data is received and we have decoded all
     // frames available but the file is truncated.
     if (index >= m_frameBufferCache.size() - 1 && isAllDataReceived() && m_reader && !m_reader->parseCompleted())
         setFailed();
 }
 
 void GIFImageDecoder::parse(GIFParseQuery query)
@@ skipping 15 matching lines @@
     // Initialize the frame rect in our buffer.
     ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
 
     size_t requiredPreviousFrameIndex = buffer->requiredPreviousFrameIndex();
     if (requiredPreviousFrameIndex == kNotFound) {
         // This frame doesn't rely on any previous data.
         if (!buffer->setSize(size().width(), size().height()))
             return setFailed();
     } else {
         const ImageFrame* prevBuffer = &m_frameBufferCache[requiredPreviousFrameIndex];
-        ASSERT(prevBuffer->status() == ImageFrame::FrameComplete);
+        ASSERT(prevBuffer->getStatus() == ImageFrame::FrameComplete);
 
         // Preserve the last frame as the starting state for this frame.
         if (!buffer->copyBitmapData(*prevBuffer))
             return setFailed();
 
-        if (prevBuffer->disposalMethod() == ImageFrame::DisposeOverwriteBgcolor) {
+        if (prevBuffer->getDisposalMethod() == ImageFrame::DisposeOverwriteBgcolor) {
             // We want to clear the previous frame to transparent, without
             // affecting pixels in the image outside of the frame.
             const IntRect& prevRect = prevBuffer->originalFrameRect();
             ASSERT(!prevRect.contains(IntRect(IntPoint(), size())));
             buffer->zeroFillFrameRect(prevRect);
         }
     }
 
     // Update our status to be partially complete.
     buffer->setStatus(ImageFrame::FramePartial);
 
     // Reset the alpha pixel tracker for this frame.
     m_currentBufferSawAlpha = false;
     return true;
 }
 
 } // namespace blink