WTF::notFound looks too much like a local variable.

Source/core/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 105 matching lines @@
     ImageFrame& frame = m_frameBufferCache[index];
     if (frame.status() == ImageFrame::FrameComplete)
         return &frame;
 
     if (RuntimeEnabledFeatures::animatedWebPEnabled()) {
         Vector<size_t> framesToDecode;
         size_t frameToDecode = index;
         do {
             framesToDecode.append(frameToDecode);
             frameToDecode = m_frameBufferCache[frameToDecode].requiredPreviousFrameIndex();
-        } while (frameToDecode != notFound && m_frameBufferCache[frameToDecode].status() != ImageFrame::FrameComplete);
+        } while (frameToDecode != kNotFound && m_frameBufferCache[frameToDecode].status() != ImageFrame::FrameComplete);
 
         ASSERT(m_demux);
         for (size_t i = framesToDecode.size(); i > 0; --i) {
             size_t frameIndex = framesToDecode[i - 1];
             if ((m_formatFlags & ANIMATION_FLAG) && !initFrameBuffer(frameIndex))
                 return 0;
             WebPIterator webpFrame;
             if (!WebPDemuxGetFrame(m_demux, frameIndex + 1, &webpFrame))
                 return 0;
             PlatformInstrumentation::willDecodeImage("WEBP");
@@ skipping 94 matching lines @@
         m_haveReadAnimationParameters = true;
     }
 
     const size_t oldFrameCount = m_frameBufferCache.size();
     if (newFrameCount > oldFrameCount) {
         m_frameBufferCache.resize(newFrameCount);
         for (size_t i = oldFrameCount; i < newFrameCount; ++i) {
             m_frameBufferCache[i].setPremultiplyAlpha(m_premultiplyAlpha);
             if (!hasAnimation) {
                 ASSERT(!i);
-                m_frameBufferCache[i].setRequiredPreviousFrameIndex(notFound);
+                m_frameBufferCache[i].setRequiredPreviousFrameIndex(kNotFound);
                 continue;
             }
             WebPIterator animatedFrame;
             WebPDemuxGetFrame(m_demux, i + 1, &animatedFrame);
             ASSERT(animatedFrame.complete == 1);
             m_frameBufferCache[i].setDuration(animatedFrame.duration);
             m_frameBufferCache[i].setDisposalMethod(animatedFrame.dispose_method == WEBP_MUX_DISPOSE_BACKGROUND ? ImageFrame::DisposeOverwriteBgcolor : ImageFrame::DisposeKeep);
             m_frameBufferCache[i].setAlphaBlendSource(animatedFrame.blend_method == WEBP_MUX_BLEND ? ImageFrame::BlendAtopPreviousFrame : ImageFrame::BlendAtopBgcolor);
             IntRect frameRect(animatedFrame.x_offset, animatedFrame.y_offset, animatedFrame.width, animatedFrame.height);
             // Make sure the frameRect doesn't extend outside the buffer.
@@ skipping 10 matching lines @@
     return true;
 }
 
 bool WEBPImageDecoder::initFrameBuffer(size_t frameIndex)
 {
     ImageFrame& buffer = m_frameBufferCache[frameIndex];
     if (buffer.status() != ImageFrame::FrameEmpty) // Already initialized.
         return true;
 
     const size_t requiredPreviousFrameIndex = buffer.requiredPreviousFrameIndex();
-    if (requiredPreviousFrameIndex == notFound) {
+    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);
 
         // Preserve the last frame as the starting state for this frame.
         if (!buffer.copyBitmapData(prevBuffer))
@@ skipping 126 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() != notFound) {
+    if ((m_formatFlags & ANIMATION_FLAG) && frameIndex && buffer.alphaBlendSource() == ImageFrame::BlendAtopPreviousFrame && buffer.requiredPreviousFrameIndex() != kNotFound) {
         ImageFrame& prevBuffer = m_frameBufferCache[frameIndex - 1];
         ASSERT(prevBuffer.status() == ImageFrame::FrameComplete);
         ImageFrame::DisposalMethod prevDisposalMethod = prevBuffer.disposalMethod();
         if (prevDisposalMethod == ImageFrame::DisposeKeep) { // Restore transparent pixels to pixels in previous canvas.
             for (int y = m_decodedHeight; y < decodedHeight; ++y) {
                 const int canvasY = top + y;
                 for (int x = 0; x < width; ++x) {
                     const int canvasX = left + x;
                     ImageFrame::PixelData& pixel = *buffer.getAddr(canvasX, canvasY);
                     // FIXME: Use alpha-blending when alpha is between 0 and 255.
@@ skipping 96 matching lines @@
     case VP8_STATUS_SUSPENDED:
         applyPostProcessing(frameIndex);
         return false;
     default:
         clear();
         return setFailed();
     }
 }
 
 } // namespace WebCore