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

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

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 124 matching lines @@
 
 void testByteByByteSizeAvailable(const char* webpFile,
                                  size_t frameOffset,
                                  bool hasColorProfile,
                                  int expectedRepetitionCount) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
   RefPtr<SharedBuffer> data = readFile(webpFile);
   ASSERT_TRUE(data.get());
   EXPECT_LT(frameOffset, data->size());
 
-  // Send data to the decoder byte-by-byte and use the provided frame offset in the data to check
-  // isSizeAvailable() changes state only when that offset is reached, and the associated decoder
-  // state also: size, colorProfile, frameCount, repetitionCount ...
-
+  // Send data to the decoder byte-by-byte and use the provided frame offset in
+  // the data to check that isSizeAvailable() changes state only when that
+  // offset is reached. Also check other decoder state.
   for (size_t length = 1; length <= frameOffset; ++length) {
     RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), length);
     decoder->setData(tempData.get(), false);
 
     if (length < frameOffset) {
       EXPECT_FALSE(decoder->isSizeAvailable());
       EXPECT_TRUE(decoder->size().isEmpty());
       EXPECT_FALSE(decoder->hasColorProfile());
       EXPECT_EQ(0u, decoder->frameCount());
       EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
@@ skipping 71 matching lines @@
           maxDifference = difference;
       }
     }
   }
 
   // Pre-multiplication could round the RGBA channel values. So, we declare
   // that the frames match if the RGBA channel values differ by at most 2.
   EXPECT_GE(2, maxDifference) << webpFile;
 }
 
-// Verify that result of alpha blending is similar for AlphaPremultiplied and AlphaNotPremultiplied cases.
+// Verifies that result of alpha blending is similar for AlphaPremultiplied and
+// AlphaNotPremultiplied cases.
 void testAlphaBlending(const char* webpFile) {
   RefPtr<SharedBuffer> data = readFile(webpFile);
   ASSERT_TRUE(data.get());
 
   std::unique_ptr<ImageDecoder> decoderA =
       createDecoder(ImageDecoder::AlphaPremultiplied);
   decoderA->setData(data.get(), true);
 
   std::unique_ptr<ImageDecoder> decoderB =
       createDecoder(ImageDecoder::AlphaNotPremultiplied);
@@ skipping 222 matching lines @@
 
   ImageFrame* frame = decoder->frameBufferAtIndex(1);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
   frame = decoder->frameBufferAtIndex(2);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::FramePartial, frame->getStatus());
   EXPECT_TRUE(decoder->failed());
 }
 
-// Reproduce a crash that used to happen for a specific file with specific sequence of method calls.
+// Tests for a crash that used to happen for a specific file with specific
+// sequence of method calls.
 TEST(AnimatedWebPTests, reproCrash) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> fullData =
       readFile("/LayoutTests/fast/images/resources/invalid_vp8_vp8x.webp");
   ASSERT_TRUE(fullData.get());
 
   // Parse partial data up to which error in bitstream is not detected.
   const size_t partialSize = 32768;
   ASSERT_GT(fullData->size(), partialSize);
@@ skipping 94 matching lines @@
   EXPECT_EQ(1000.0, decoder->frameDurationAtIndex(2));
 }
 
 TEST(AnimatedWebPTests, updateRequiredPreviousFrameAfterFirstDecode) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> fullData =
       readFile("/LayoutTests/fast/images/resources/webp-animated.webp");
   ASSERT_TRUE(fullData.get());
 
-  // Give it data that is enough to parse but not decode in order to check the status
-  // of requiredPreviousFrameIndex before decoding.
+  // Check the status of requiredPreviousFrameIndex before decoding, by
+  // supplying data sufficient to parse but not decode.
   size_t partialSize = 1;
   do {
     RefPtr<SharedBuffer> data =
         SharedBuffer::create(fullData->data(), partialSize);
     decoder->setData(data.get(), false);
     ++partialSize;
   } while (!decoder->frameCount() ||
            decoder->frameBufferAtIndex(0)->getStatus() ==
                ImageFrame::FrameEmpty);
 
@@ skipping 96 matching lines @@
       false, 32000);
 }
 
 TEST(StaticWebPTests, truncatedImage) {
   // VP8 data is truncated.
   testInvalidImage("/LayoutTests/fast/images/resources/truncated.webp", false);
   // Chunk size in RIFF header doesn't match the file size.
   testInvalidImage("/LayoutTests/fast/images/resources/truncated2.webp", true);
 }
 
+// Regression test for a bug where some valid images were failing to decode
+// incrementally.
 TEST(StaticWebPTests, incrementalDecode) {
-  // Regression test for a bug where some valid images were failing to decode incrementally.
   testByteByByteDecode(&createDecoder,
                        "/LayoutTests/fast/images/resources/crbug.364830.webp",
                        1u, cAnimationNone);
 }
 
 TEST(StaticWebPTests, isSizeAvailable) {
   testByteByByteSizeAvailable(
       "/LayoutTests/fast/images/resources/webp-color-profile-lossy.webp", 520u,
       true, cAnimationNone);
   testByteByByteSizeAvailable("/LayoutTests/fast/images/resources/test.webp",
                               30u, false, cAnimationNone);
 }
 
 TEST(StaticWebPTests, notAnimated) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
   RefPtr<SharedBuffer> data = readFile(
       "/LayoutTests/fast/images/resources/webp-color-profile-lossy.webp");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
   EXPECT_EQ(1u, decoder->frameCount());
   EXPECT_EQ(cAnimationNone, decoder->repetitionCount());
 }
 
 }  // namespace blink