Rewrap comments to 80 columns in Source/platform/graphics/.

third_party/WebKit/Source/platform/graphics/ImageFrameGenerator.cpp

 /*
  * Copyright (C) 2012 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 21 matching lines @@
 #include "third_party/skia/include/core/SkYUVSizeInfo.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
 static bool compatibleInfo(const SkImageInfo& src, const SkImageInfo& dst) {
   if (src == dst)
     return true;
 
-  // It is legal to write kOpaque_SkAlphaType pixels into a kPremul_SkAlphaType buffer.
-  // This can happen when DeferredImageDecoder allocates an kOpaque_SkAlphaType image
-  // generator based on cached frame info, while the ImageFrame-allocated dest bitmap
-  // stays kPremul_SkAlphaType.
+  // It is legal to write kOpaque_SkAlphaType pixels into a kPremul_SkAlphaType
+  // buffer. This can happen when DeferredImageDecoder allocates an
+  // kOpaque_SkAlphaType image generator based on cached frame info, while the
+  // ImageFrame-allocated dest bitmap stays kPremul_SkAlphaType.
   if (src.alphaType() == kOpaque_SkAlphaType &&
       dst.alphaType() == kPremul_SkAlphaType) {
     const SkImageInfo& tmp = src.makeAlphaType(kPremul_SkAlphaType);
     return tmp == dst;
   }
 
   return false;
 }
 
-// Creates a SkPixelRef such that the memory for pixels is given by an external body.
-// This is used to write directly to the memory given by Skia during decoding.
+// Creates a SkPixelRef such that the memory for pixels is given by an external
+// body. This is used to write directly to the memory given by Skia during
+// decoding.
 class ExternalMemoryAllocator final : public SkBitmap::Allocator {
   USING_FAST_MALLOC(ExternalMemoryAllocator);
   WTF_MAKE_NONCOPYABLE(ExternalMemoryAllocator);
 
  public:
   ExternalMemoryAllocator(const SkImageInfo& info,
                           void* pixels,
                           size_t rowBytes)
       : m_info(info), m_pixels(pixels), m_rowBytes(rowBytes) {}
 
@@ skipping 83 matching lines @@
   if (bitmap.getPixels() != pixels)
     return bitmap.copyPixelsTo(pixels, rowBytes * info.height(), rowBytes);
   return true;
 }
 
 bool ImageFrameGenerator::decodeToYUV(SegmentReader* data,
                                       size_t index,
                                       const SkISize componentSizes[3],
                                       void* planes[3],
                                       const size_t rowBytes[3]) {
-  // TODO (scroggo): The only interesting thing this uses from the ImageFrameGenerator is m_decodeFailed.
-  // Move this into DecodingImageGenerator, which is the only class that calls it.
+  // TODO (scroggo): The only interesting thing this uses from the
+  // ImageFrameGenerator is m_decodeFailed. Move this into
+  // DecodingImageGenerator, which is the only class that calls it.
   if (m_decodeFailed)
     return false;
 
   TRACE_EVENT1("blink", "ImageFrameGenerator::decodeToYUV", "frame index",
                static_cast<int>(index));
 
   if (!planes || !planes[0] || !planes[1] || !planes[2] || !rowBytes ||
       !rowBytes[0] || !rowBytes[1] || !rowBytes[2]) {
     return false;
   }
 
   std::unique_ptr<ImageDecoder> decoder =
       ImageDecoder::create(data, true, ImageDecoder::AlphaPremultiplied,
                            ImageDecoder::GammaAndColorProfileApplied);
-  // getYUVComponentSizes was already called and was successful, so ImageDecoder::create must succeed.
+  // getYUVComponentSizes was already called and was successful, so
+  // ImageDecoder::create must succeed.
   ASSERT(decoder);
 
   std::unique_ptr<ImagePlanes> imagePlanes =
       wrapUnique(new ImagePlanes(planes, rowBytes));
   decoder->setImagePlanes(std::move(imagePlanes));
 
   ASSERT(decoder->canDecodeToYUV());
 
   if (decoder->decodeToYUV()) {
     setHasAlpha(0, false);  // YUV is always opaque
@@ skipping 173 matching lines @@
 
   if (m_yuvDecodingFailed)
     return false;
 
   std::unique_ptr<ImageDecoder> decoder =
       ImageDecoder::create(data, true, ImageDecoder::AlphaPremultiplied,
                            ImageDecoder::GammaAndColorProfileApplied);
   if (!decoder)
     return false;
 
-  // Setting a dummy ImagePlanes object signals to the decoder that we want to do YUV decoding.
+  // Setting a dummy ImagePlanes object signals to the decoder that we want to
+  // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummyImagePlanes = wrapUnique(new ImagePlanes);
   decoder->setImagePlanes(std::move(dummyImagePlanes));
 
   return updateYUVComponentSizes(decoder.get(), sizeInfo->fSizes,
                                  sizeInfo->fWidthBytes);
 }
 
 }  // namespace blink