reflow comments in core/frame

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/frame/ImageBitmap.h"
 
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "platform/graphics/skia/SkiaUtils.h"
@@ skipping 13 matching lines @@
 namespace {
 
 struct ParsedOptions {
   bool flipY = false;
   bool premultiplyAlpha = true;
   bool shouldScaleInput = false;
   unsigned resizeWidth = 0;
   unsigned resizeHeight = 0;
   IntRect cropRect;
   SkFilterQuality resizeQuality = kLow_SkFilterQuality;
-  // This value should be changed in the future when we support createImageBitmap with higher
-  // bit depth, in the parseOptions() function. For now, it is always 4.
+  // This value should be changed in the future when we support
+  // createImageBitmap with higher bit depth, in the parseOptions() function.
+  // For now, it is always 4.
   int bytesPerPixel = 4;
 };
 
 // The following two functions are helpers used in cropImage
 static inline IntRect normalizeRect(const IntRect& rect) {
   return IntRect(std::min(rect.x(), rect.maxX()),
                  std::min(rect.y(), rect.maxY()),
                  std::max(rect.width(), -rect.width()),
                  std::max(rect.height(), -rect.height()));
 }
@@ skipping 75 matching lines @@
   if (!totalBytes.IsValid())
     return true;
 
   return false;
 }
 
 }  // namespace
 
 static PassRefPtr<Uint8Array> copySkImageData(SkImage* input,
                                               const SkImageInfo& info) {
-  // The function dstBufferSizeHasOverflow() is being called at the beginning of each
-  // ImageBitmap() constructor, which makes sure that doing width * height * bytesPerPixel
-  // will never overflow size_t.
+  // The function dstBufferSizeHasOverflow() is being called at the beginning of
+  // each ImageBitmap() constructor, which makes sure that doing
+  // width * height * bytesPerPixel will never overflow size_t.
   size_t width = static_cast<size_t>(input->width());
   RefPtr<ArrayBuffer> dstBuffer =
       ArrayBuffer::createOrNull(width * input->height(), info.bytesPerPixel());
   if (!dstBuffer)
     return nullptr;
   RefPtr<Uint8Array> dstPixels =
       Uint8Array::create(dstBuffer, 0, dstBuffer->byteLength());
   input->readPixels(info, dstPixels->data(), width * info.bytesPerPixel(), 0,
                     0);
   return dstPixels;
@@ skipping 115 matching lines @@
                                     ExceptionState& exceptionState) {
   if (!sourceWidth || !sourceHeight) {
     exceptionState.throwDOMException(
         IndexSizeError, String::format("The source %s provided is 0.",
                                        sourceWidth ? "height" : "width"));
     return false;
   }
   return true;
 }
 
-// The parameter imageFormat indicates whether the first parameter "image" is unpremultiplied or not.
-// imageFormat = PremultiplyAlpha means the image is in premuliplied format
-// For example, if the image is already in unpremultiplied format and we want the created ImageBitmap
-// in the same format, then we don't need to use the ImageDecoder to decode the image.
+// The parameter imageFormat indicates whether the first parameter "image" is
+// unpremultiplied or not.  imageFormat = PremultiplyAlpha means the image is in
+// premuliplied format For example, if the image is already in unpremultiplied
+// format and we want the created ImageBitmap in the same format, then we don't
+// need to use the ImageDecoder to decode the image.
 static PassRefPtr<StaticBitmapImage> cropImage(
     Image* image,
     const ParsedOptions& parsedOptions,
     AlphaDisposition imageFormat = PremultiplyAlpha,
     ImageDecoder::GammaAndColorProfileOption colorSpaceOp =
         ImageDecoder::GammaAndColorProfileApplied) {
   ASSERT(image);
   IntRect imgRect(IntPoint(), IntSize(image->width(), image->height()));
   const IntRect srcRect = intersection(imgRect, parsedOptions.cropRect);
 
-  // In the case when cropRect doesn't intersect the source image and it requires a umpremul image
-  // We immediately return a transparent black image with cropRect.size()
+  // In the case when cropRect doesn't intersect the source image and it
+  // requires a umpremul image We immediately return a transparent black image
+  // with cropRect.size()
   if (srcRect.isEmpty() && !parsedOptions.premultiplyAlpha) {
     SkImageInfo info =
         SkImageInfo::Make(parsedOptions.resizeWidth, parsedOptions.resizeHeight,
                           kN32_SkColorType, kUnpremul_SkAlphaType);
     RefPtr<ArrayBuffer> dstBuffer = ArrayBuffer::createOrNull(
         static_cast<size_t>(info.width()) * info.height(),
         info.bytesPerPixel());
     if (!dstBuffer)
       return nullptr;
     RefPtr<Uint8Array> dstPixels =
         Uint8Array::create(dstBuffer, 0, dstBuffer->byteLength());
     return StaticBitmapImage::create(newSkImageFromRaster(
         info, std::move(dstPixels),
         static_cast<size_t>(info.width()) * info.bytesPerPixel()));
   }
 
   sk_sp<SkImage> skiaImage = image->imageForCurrentFrame();
-  // Attempt to get raw unpremultiplied image data, executed only when skiaImage is premultiplied.
+  // Attempt to get raw unpremultiplied image data, executed only when skiaImage
+  // is premultiplied.
   if ((((!parsedOptions.premultiplyAlpha && !skiaImage->isOpaque()) ||
         !skiaImage) &&
        image->data() && imageFormat == PremultiplyAlpha) ||
       colorSpaceOp == ImageDecoder::GammaAndColorProfileIgnored) {
     std::unique_ptr<ImageDecoder> decoder(ImageDecoder::create(
         image->data(), true,
         parsedOptions.premultiplyAlpha ? ImageDecoder::AlphaPremultiplied
                                        : ImageDecoder::AlphaNotPremultiplied,
         colorSpaceOp));
     if (!decoder)
       return nullptr;
     skiaImage = ImageBitmap::getSkImageFromDecoder(std::move(decoder));
     if (!skiaImage)
       return nullptr;
   }
 
   if (parsedOptions.cropRect == srcRect && !parsedOptions.shouldScaleInput) {
     sk_sp<SkImage> croppedSkImage = skiaImage->makeSubset(srcRect);
     if (parsedOptions.flipY)
       return StaticBitmapImage::create(flipSkImageVertically(
           croppedSkImage.get(), parsedOptions.premultiplyAlpha
                                     ? PremultiplyAlpha
                                     : DontPremultiplyAlpha));
-    // Special case: The first parameter image is unpremul but we need to turn it into premul.
+    // Special case: The first parameter image is unpremul but we need to turn
+    // it into premul.
     if (parsedOptions.premultiplyAlpha && imageFormat == DontPremultiplyAlpha)
       return StaticBitmapImage::create(
           unPremulSkImageToPremul(croppedSkImage.get()));
     // Call preroll to trigger image decoding.
     croppedSkImage->preroll();
     return StaticBitmapImage::create(std::move(croppedSkImage));
   }
 
   sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
       parsedOptions.resizeWidth, parsedOptions.resizeHeight);
@@ skipping 514 matching lines @@
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect,
                                   FloatRect* dstRect) const {}
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink