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

third_party/WebKit/Source/platform/image-decoders/webp/WEBPImageDecoder.cpp

 /*
  * Copyright (C) 2010 Google 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
@@ skipping 232 matching lines @@
 #endif
     }
 
     ASSERT(isDecodedSizeAvailable());
     return true;
 }
 
 bool WEBPImageDecoder::initFrameBuffer(size_t frameIndex)
 {
     ImageFrame& buffer = m_frameBufferCache[frameIndex];
-    if (buffer.status() != ImageFrame::FrameEmpty) // Already initialized.
+    if (buffer.getStatus() != ImageFrame::FrameEmpty) // Already initialized.
         return true;
 
     const 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();
         m_frameBackgroundHasAlpha = !buffer.originalFrameRect().contains(IntRect(IntPoint(), size()));
     } 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);
         }
 
-        m_frameBackgroundHasAlpha = prevBuffer.hasAlpha() || (prevBuffer.disposalMethod() == ImageFrame::DisposeOverwriteBgcolor);
+        m_frameBackgroundHasAlpha = prevBuffer.hasAlpha() || (prevBuffer.getDisposalMethod() == ImageFrame::DisposeOverwriteBgcolor);
     }
 
     buffer.setStatus(ImageFrame::FramePartial);
     // The buffer is transparent outside the decoded area while the image is loading.
     // The correct value of 'hasAlpha' for the frame will be set when it is fully decoded.
     buffer.setHasAlpha(true);
     return true;
 }
 
 size_t WEBPImageDecoder::clearCacheExceptFrame(size_t clearExceptFrame)
 {
     // If |clearExceptFrame| has status FrameComplete, we preserve that frame.
     // Otherwise, we preserve a previous frame with status FrameComplete whose data is required
     // to decode |clearExceptFrame|, either in initFrameBuffer() or ApplyPostProcessing().
     // All other frames can be cleared.
-    while ((clearExceptFrame < m_frameBufferCache.size()) && (m_frameBufferCache[clearExceptFrame].status() != ImageFrame::FrameComplete))
+    while ((clearExceptFrame < m_frameBufferCache.size()) && (m_frameBufferCache[clearExceptFrame].getStatus() != ImageFrame::FrameComplete))
         clearExceptFrame = m_frameBufferCache[clearExceptFrame].requiredPreviousFrameIndex();
 
     return ImageDecoder::clearCacheExceptFrame(clearExceptFrame);
 }
 
 void WEBPImageDecoder::clearFrameBuffer(size_t frameIndex)
 {
-    if (m_demux && m_demuxState >= WEBP_DEMUX_PARSED_HEADER && m_frameBufferCache[frameIndex].status() == ImageFrame::FramePartial) {
+    if (m_demux && m_demuxState >= WEBP_DEMUX_PARSED_HEADER && m_frameBufferCache[frameIndex].getStatus() == ImageFrame::FramePartial) {
         // Clear the decoder state so that this partial frame can be decoded again when requested.
         clearDecoder();
     }
     ImageDecoder::clearFrameBuffer(frameIndex);
 }
 
 #if USE(QCMSLIB)
 
 void WEBPImageDecoder::clearColorTransform()
 {
@@ skipping 88 matching lines @@
         }
     }
 #endif // USE(QCMSLIB)
 
     // During the decoding of current frame, we may have set some pixels to be transparent (i.e. alpha < 255).
     // However, the value of each of these pixels should have been determined by blending it against the value
     // of that pixel in the previous frame if alpha blend source was 'BlendAtopPreviousFrame'. So, we correct these
     // pixels based on disposal method of the previous frame and the previous frame buffer.
     // FIXME: This could be avoided if libwebp decoder had an API that used the previous required frame
     // to do the alpha-blending by itself.
-    if ((m_formatFlags & ANIMATION_FLAG) && frameIndex && buffer.alphaBlendSource() == ImageFrame::BlendAtopPreviousFrame && buffer.requiredPreviousFrameIndex() != kNotFound) {
+    if ((m_formatFlags & ANIMATION_FLAG) && frameIndex && buffer.getAlphaBlendSource() == ImageFrame::BlendAtopPreviousFrame && buffer.requiredPreviousFrameIndex() != kNotFound) {
         ImageFrame& prevBuffer = m_frameBufferCache[frameIndex - 1];
-        ASSERT(prevBuffer.status() == ImageFrame::FrameComplete);
-        ImageFrame::DisposalMethod prevDisposalMethod = prevBuffer.disposalMethod();
+        ASSERT(prevBuffer.getStatus() == ImageFrame::FrameComplete);
+        ImageFrame::DisposalMethod prevDisposalMethod = prevBuffer.getDisposalMethod();
         if (prevDisposalMethod == ImageFrame::DisposeKeep) { // Blend transparent pixels with pixels in previous canvas.
             for (int y = m_decodedHeight; y < decodedHeight; ++y) {
                 m_blendFunction(buffer, prevBuffer, top + y, left, width);
             }
         } else if (prevDisposalMethod == ImageFrame::DisposeOverwriteBgcolor) {
             const IntRect& prevRect = prevBuffer.originalFrameRect();
             // We need to blend a transparent pixel with its value just after initFrame() call. That is:
             //   * Blend with fully transparent pixel if it belongs to prevRect <-- This is a no-op.
             //   * Blend with the pixel in the previous canvas otherwise <-- Needs alpha-blending.
             for (int y = m_decodedHeight; y < decodedHeight; ++y) {
@@ skipping 42 matching lines @@
 void WEBPImageDecoder::decode(size_t index)
 {
     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);
 
     ASSERT(m_demux);
     for (auto i = framesToDecode.rbegin(); i != framesToDecode.rend(); ++i) {
         if ((m_formatFlags & ANIMATION_FLAG) && !initFrameBuffer(*i))
             return;
         WebPIterator webpFrame;
         if (!WebPDemuxGetFrame(m_demux, *i + 1, &webpFrame)) {
             setFailed();
         } else {
             decodeSingleFrame(webpFrame.fragment.bytes, webpFrame.fragment.size, *i);
             WebPDemuxReleaseIterator(&webpFrame);
         }
         if (failed())
             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_demux && m_demuxState != WEBP_DEMUX_DONE)
         setFailed();
 }
 
 bool WEBPImageDecoder::decodeSingleFrame(const uint8_t* dataBytes, size_t dataSize, size_t frameIndex)
 {
     if (failed())
         return false;
 
     ASSERT(isDecodedSizeAvailable());
 
     ASSERT(m_frameBufferCache.size() > frameIndex);
     ImageFrame& buffer = m_frameBufferCache[frameIndex];
-    ASSERT(buffer.status() != ImageFrame::FrameComplete);
+    ASSERT(buffer.getStatus() != ImageFrame::FrameComplete);
 
-    if (buffer.status() == ImageFrame::FrameEmpty) {
+    if (buffer.getStatus() == ImageFrame::FrameEmpty) {
         if (!buffer.setSize(size().width(), size().height()))
             return setFailed();
         buffer.setStatus(ImageFrame::FramePartial);
         // The buffer is transparent outside the decoded area while the image is loading.
         // The correct value of 'hasAlpha' for the frame will be set when it is fully decoded.
         buffer.setHasAlpha(true);
         buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
     }
 
     const IntRect& frameRect = buffer.originalFrameRect();
@@ skipping 30 matching lines @@
             return false;
         }
         // FALLTHROUGH
     default:
         clear();
         return setFailed();
     }
 }
 
 } // namespace blink