Rewrap comments to 80 columns in Source/platform/image-decoders/.

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 59 matching lines @@
   uint8_t blendR = blendChannel(SkGetPackedR32(src), srcA, SkGetPackedR32(dst),
                                 dstFactorA, scale);
   uint8_t blendG = blendChannel(SkGetPackedG32(src), srcA, SkGetPackedG32(dst),
                                 dstFactorA, scale);
   uint8_t blendB = blendChannel(SkGetPackedB32(src), srcA, SkGetPackedB32(dst),
                                 dstFactorA, scale);
 
   return SkPackARGB32NoCheck(blendA, blendR, blendG, blendB);
 }
 
-// Returns two point ranges (<left, width> pairs) at row 'canvasY', that belong to 'src' but not 'dst'.
-// A point range is empty if the corresponding width is 0.
+// Returns two point ranges (<left, width> pairs) at row |canvasY| which belong
+// to |src| but not |dst|. A range is empty if its width is 0.
 inline void findBlendRangeAtRow(const blink::IntRect& src,
                                 const blink::IntRect& dst,
                                 int canvasY,
                                 int& left1,
                                 int& width1,
                                 int& left2,
                                 int& width2) {
   ASSERT_WITH_SECURITY_IMPLICATION(canvasY >= src.y() && canvasY < src.maxY());
   left1 = -1;
   width1 = 0;
@@ skipping 200 matching lines @@
       ASSERT(!prevRect.contains(IntRect(IntPoint(), size())));
       buffer.zeroFillFrameRect(prevRect);
     }
 
     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.
+  // The buffer is transparent outside the decoded area while the image is
+  // loading. The correct alpha value 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.
+  // Otherwise, we preserve the most recent previous frame with status
+  // FrameComplete whose data will be required to decode |clearExceptFrame|,
+  // either in initFrameBuffer() or ApplyPostProcessing(). All other frames can
+  // be cleared.
   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].getStatus() == ImageFrame::FramePartial) {
-    // Clear the decoder state so that this partial frame can be decoded again when requested.
+    // Clear the decoder state so that this partial frame can be decoded again
+    // when requested.
     clearDecoder();
   }
   ImageDecoder::clearFrameBuffer(frameIndex);
 }
 
 void WEBPImageDecoder::readColorProfile() {
   WebPChunkIterator chunkIterator;
   if (!WebPDemuxGetChunk(m_demux, "ICCP", 1, &chunkIterator)) {
     WebPDemuxReleaseChunkIterator(&chunkIterator);
     return;
@@ skipping 33 matching lines @@
       uint8_t* pixel = row;
       for (int x = 0; x < width; ++x, pixel += 4) {
         const int canvasX = left + x;
         buffer.setRGBA(canvasX, canvasY, pixel[0], pixel[1], pixel[2],
                        pixel[3]);
       }
     }
   }
 #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.
+  // During the decoding of the current frame, we may have set some pixels to be
+  // transparent (i.e. alpha < 255). If the alpha blend source was
+  // 'BlendAtopPreviousFrame', the values of these pixels should be determined
+  // by blending them against the pixels of the corresponding previous frame.
+  // Compute the correct opaque values now.
+  // 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.getAlphaBlendSource() == ImageFrame::BlendAtopPreviousFrame &&
       buffer.requiredPreviousFrameIndex() != kNotFound) {
     ImageFrame& prevBuffer = m_frameBufferCache[frameIndex - 1];
     ASSERT(prevBuffer.getStatus() == ImageFrame::FrameComplete);
     ImageFrame::DisposalMethod prevDisposalMethod =
         prevBuffer.getDisposalMethod();
-    if (prevDisposalMethod ==
-        ImageFrame::
-            DisposeKeep) {  // Blend transparent pixels with pixels in previous canvas.
+    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.
+      // We need to blend a transparent pixel with the starting value (from just
+      // after the initFrame() call). If the pixel belongs to prevRect, the
+      // starting value was fully transparent, so this is a no-op. Otherwise, we
+      // need to blend against the pixel from the previous canvas.
       for (int y = m_decodedHeight; y < decodedHeight; ++y) {
         int canvasY = top + y;
         int left1, width1, left2, width2;
         findBlendRangeAtRow(frameRect, prevRect, canvasY, left1, width1, left2,
                             width2);
         if (width1 > 0)
           m_blendFunction(buffer, prevBuffer, canvasY, left1, width1);
         if (width2 > 0)
           m_blendFunction(buffer, prevBuffer, canvasY, left2, width2);
       }
@@ skipping 88 matching lines @@
 
   ASSERT(m_frameBufferCache.size() > frameIndex);
   ImageFrame& buffer = m_frameBufferCache[frameIndex];
   ASSERT(buffer.getStatus() != ImageFrame::FrameComplete);
 
   if (buffer.getStatus() == ImageFrame::FrameEmpty) {
     if (!buffer.setSizeAndColorProfile(size().width(), size().height(),
                                        colorProfile()))
       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.
+    // The buffer is transparent outside the decoded area while the image is
+    // loading. The correct alpha value for the frame will be set when it is
+    // fully decoded.
     buffer.setHasAlpha(true);
     buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
   }
 
   const IntRect& frameRect = buffer.originalFrameRect();
   if (!m_decoder) {
     WEBP_CSP_MODE mode = outputMode(m_formatFlags & ALPHA_FLAG);
     if (!m_premultiplyAlpha)
       mode = outputMode(false);
 #if USE(QCMSLIB)
@@ skipping 29 matching lines @@
         return false;
       }
     // FALLTHROUGH
     default:
       clear();
       return setFailed();
   }
 }
 
 }  // namespace blink