Pull up equivalent image decoding tests

third_party/WebKit/Source/platform/image-decoders/gif/GIFImageDecoderTest.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 33 matching lines @@
 namespace {
 
 const char layoutTestResourcesDir[] = "LayoutTests/fast/images/resources";
 
 std::unique_ptr<ImageDecoder> createDecoder() {
   return wrapUnique(new GIFImageDecoder(ImageDecoder::AlphaNotPremultiplied,
                                         ImageDecoder::ColorSpaceApplied,
                                         ImageDecoder::noDecodedImageByteLimit));
 }
 
-void testRandomFrameDecode(const char* dir, const char* gifFile) {
-  SCOPED_TRACE(gifFile);
+void testRepetitionCount(const char *dir, const char* file,

[joostouwerling, 2016/11/09 14:25:08]

An extra note about the repetition count test for GIF. The new test is different
since it does not incrementally provide the data to the decoder, in between the
tests for the repetition count. I don't think this should influence the reported
repetition count in the parsing process, but maybe I'm missing something
specific for GIF images.

If it is easier to land this CL without sharing the progressiveDecode test, I
can revert it for GIF, and change the GIF test in a different CL. 

[scroggo_chromium, 2016/11/09 14:38:37]

No, I think this is fine.

+                         int expectedRepetitionCount) {
+  std::unique_ptr<ImageDecoder> decoder = createDecoder();
+  RefPtr<SharedBuffer> data = readFile(dir, file);
+  ASSERT_TRUE(data.get());
+  decoder->setData(data.get(), true);
+  EXPECT_EQ(cAnimationLoopOnce,
+            decoder->repetitionCount());  // Default value before decode.
 
-  RefPtr<SharedBuffer> fullData = readFile(dir, gifFile);
-  ASSERT_TRUE(fullData.get());
-  Vector<unsigned> baselineHashes;
-  createDecodingBaseline(&createDecoder, fullData.get(), &baselineHashes);
-  size_t frameCount = baselineHashes.size();
-
-  // Random decoding should get the same results as sequential decoding.
-  std::unique_ptr<ImageDecoder> decoder = createDecoder();
-  decoder->setData(fullData.get(), true);
-  const size_t skippingStep = 5;
-  for (size_t i = 0; i < skippingStep; ++i) {
-    for (size_t j = i; j < frameCount; j += skippingStep) {
-      SCOPED_TRACE(testing::Message() << "Random i:" << i << " j:" << j);
-      ImageFrame* frame = decoder->frameBufferAtIndex(j);
-      EXPECT_EQ(baselineHashes[j], hashBitmap(frame->bitmap()));
-    }
+  for (size_t i = 0; i < decoder->frameCount(); ++i) {
+    ImageFrame* frame = decoder->frameBufferAtIndex(i);
+    EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
   }
 
-  // Decoding in reverse order.
-  decoder = createDecoder();
-  decoder->setData(fullData.get(), true);
-  for (size_t i = frameCount; i; --i) {
-    SCOPED_TRACE(testing::Message() << "Reverse i:" << i);
-    ImageFrame* frame = decoder->frameBufferAtIndex(i - 1);
-    EXPECT_EQ(baselineHashes[i - 1], hashBitmap(frame->bitmap()));
-  }
-}
-
-void testRandomDecodeAfterClearFrameBufferCache(const char* dir,
-                                                const char* gifFile) {
-  SCOPED_TRACE(gifFile);
-
-  RefPtr<SharedBuffer> data = readFile(dir, gifFile);
-  ASSERT_TRUE(data.get());
-  Vector<unsigned> baselineHashes;
-  createDecodingBaseline(&createDecoder, data.get(), &baselineHashes);
-  size_t frameCount = baselineHashes.size();
-
-  std::unique_ptr<ImageDecoder> decoder = createDecoder();
-  decoder->setData(data.get(), true);
-  for (size_t clearExceptFrame = 0; clearExceptFrame < frameCount;
-       ++clearExceptFrame) {
-    decoder->clearCacheExceptFrame(clearExceptFrame);
-    const size_t skippingStep = 5;
-    for (size_t i = 0; i < skippingStep; ++i) {
-      for (size_t j = 0; j < frameCount; j += skippingStep) {
-        SCOPED_TRACE(testing::Message() << "Random i:" << i << " j:" << j);
-        ImageFrame* frame = decoder->frameBufferAtIndex(j);
-        EXPECT_EQ(baselineHashes[j], hashBitmap(frame->bitmap()));
-      }
-    }
-  }
+  EXPECT_EQ(expectedRepetitionCount,
+            decoder->repetitionCount());  // Expected value after decode.
 }
 
 }  // anonymous namespace
 
 TEST(GIFImageDecoderTest, decodeTwoFrames) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> data = readFile(layoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
@@ skipping 99 matching lines @@
   ASSERT_TRUE(data.get());
   decoder->setData(data.get(), true);
 
   // One frame is detected but cannot be decoded.
   EXPECT_EQ(1u, decoder->frameCount());
   ImageFrame* frame = decoder->frameBufferAtIndex(1);
   EXPECT_FALSE(frame);
 }
 
 TEST(GIFImageDecoderTest, progressiveDecode) {
-  RefPtr<SharedBuffer> fullData = readFile(decodersTestingDir, "radient.gif");
-  ASSERT_TRUE(fullData.get());
-  const size_t fullLength = fullData->size();
-
-  std::unique_ptr<ImageDecoder> decoder;
-  ImageFrame* frame;
-
-  Vector<unsigned> truncatedHashes;
-  Vector<unsigned> progressiveHashes;
-
-  // Compute hashes when the file is truncated.
-  const size_t increment = 1;
-  for (size_t i = 1; i <= fullLength; i += increment) {
-    decoder = createDecoder();
-    RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i);
-    decoder->setData(data.get(), i == fullLength);
-    frame = decoder->frameBufferAtIndex(0);
-    if (!frame) {
-      truncatedHashes.append(0);
-      continue;
-    }
-    truncatedHashes.append(hashBitmap(frame->bitmap()));
-  }
-
-  // Compute hashes when the file is progressively decoded.
-  decoder = createDecoder();
-  EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
-  for (size_t i = 1; i <= fullLength; i += increment) {
-    RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i);
-    decoder->setData(data.get(), i == fullLength);
-    frame = decoder->frameBufferAtIndex(0);
-    if (!frame) {
-      progressiveHashes.append(0);
-      continue;
-    }
-    progressiveHashes.append(hashBitmap(frame->bitmap()));
-  }
-  EXPECT_EQ(cAnimationNone, decoder->repetitionCount());
-
-  bool match = true;
-  for (size_t i = 0; i < truncatedHashes.size(); ++i) {
-    if (truncatedHashes[i] != progressiveHashes[i]) {
-      match = false;
-      break;
-    }
-  }
-  EXPECT_TRUE(match);
+  testProgressiveDecoding(&createDecoder,
+      concatDirAndFile(decodersTestingDir, "radient.gif"));
 }
 
 TEST(GIFImageDecoderTest, allDataReceivedTruncation) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   RefPtr<SharedBuffer> data = readFile(layoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.get());
 
   ASSERT_GE(data->size(), 10u);
   RefPtr<SharedBuffer> tempData =
@@ skipping 97 matching lines @@
               decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex());
 
   decoder->setData(fullData.get(), true);
   for (size_t i = 0; i < frameCount; ++i)
     EXPECT_EQ(kNotFound,
               decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex());
 }
 
 TEST(GIFImageDecoderTest, randomFrameDecode) {
   // Single frame image.
-  testRandomFrameDecode(decodersTestingDir, "radient.gif");
+  testRandomFrameDecode(&createDecoder,
+                        concatDirAndFile(decodersTestingDir, "radient.gif"));
   // Multiple frame images.
-  testRandomFrameDecode(layoutTestResourcesDir,
-                        "animated-gif-with-offsets.gif");
-  testRandomFrameDecode(layoutTestResourcesDir, "animated-10color.gif");
+  testRandomFrameDecode(&createDecoder,
+                        concatDirAndFile(layoutTestResourcesDir,
+                                         "animated-gif-with-offsets.gif"));
+  testRandomFrameDecode(&createDecoder,
+                        concatDirAndFile(layoutTestResourcesDir,
+                                         "animated-10color.gif"));
 }
 
 TEST(GIFImageDecoderTest, randomDecodeAfterClearFrameBufferCache) {
   // Single frame image.
-  testRandomDecodeAfterClearFrameBufferCache(decodersTestingDir, "radient.gif");
+  testRandomDecodeAfterClearFrameBufferCache(&createDecoder,
+      concatDirAndFile(decodersTestingDir, "radient.gif"));
   // Multiple frame images.
-  testRandomDecodeAfterClearFrameBufferCache(layoutTestResourcesDir,
-                                             "animated-gif-with-offsets.gif");
-  testRandomDecodeAfterClearFrameBufferCache(layoutTestResourcesDir,
-                                             "animated-10color.gif");
+  testRandomDecodeAfterClearFrameBufferCache(&createDecoder,
+      concatDirAndFile(layoutTestResourcesDir, "animated-gif-with-offsets.gif"));
+  testRandomDecodeAfterClearFrameBufferCache(&createDecoder,
+      concatDirAndFile(layoutTestResourcesDir, "animated-10color.gif"));
 }
 
 TEST(GIFImageDecoderTest, resumePartialDecodeAfterClearFrameBufferCache) {
   RefPtr<SharedBuffer> fullData =
       readFile(layoutTestResourcesDir, "animated-10color.gif");
   ASSERT_TRUE(fullData.get());
   Vector<unsigned> baselineHashes;
   createDecodingBaseline(&createDecoder, fullData.get(), &baselineHashes);
   size_t frameCount = baselineHashes.size();
 
@@ skipping 88 matching lines @@
       frameSize = decoder->decodedSize();
       continue;
     }
 
     ASSERT_EQ(frameSize.width(), decoder->decodedSize().width());
     ASSERT_EQ(frameSize.height(), decoder->decodedSize().height());
   }
 }
 
 TEST(GIFImageDecoderTest, verifyRepetitionCount) {
-  const int expectedRepetitionCount = 2;
-  std::unique_ptr<ImageDecoder> decoder = createDecoder();
-  RefPtr<SharedBuffer> data = readFile(layoutTestResourcesDir, "full2loop.gif");
-  ASSERT_TRUE(data.get());
-  decoder->setData(data.get(), true);
-  EXPECT_EQ(cAnimationLoopOnce,
-            decoder->repetitionCount());  // Default value before decode.
-
-  for (size_t i = 0; i < decoder->frameCount(); ++i) {
-    ImageFrame* frame = decoder->frameBufferAtIndex(i);
-    EXPECT_EQ(ImageFrame::FrameComplete, frame->getStatus());
-  }
-
-  EXPECT_EQ(expectedRepetitionCount,
-            decoder->repetitionCount());  // Expected value after decode.
+  testRepetitionCount(layoutTestResourcesDir, "full2loop.gif", 2);
+  testRepetitionCount(decodersTestingDir, "radient.gif", cAnimationNone);
 }
 
 TEST(GIFImageDecoderTest, bitmapAlphaType) {
   RefPtr<SharedBuffer> fullData = readFile(decodersTestingDir, "radient.gif");
   ASSERT_TRUE(fullData.get());
 
   // Empirically chosen truncation size:
   //   a) large enough to produce a partial frame &&
   //   b) small enough to not fully decode the frame
   const size_t kTruncateSize = 800;
@@ skipping 33 matching lines @@
   EXPECT_TRUE(premulFrame &&
               premulFrame->getStatus() == ImageFrame::FrameComplete);
   EXPECT_EQ(premulFrame->bitmap().alphaType(), kOpaque_SkAlphaType);
   unpremulFrame = unpremulDecoder->frameBufferAtIndex(0);
   EXPECT_TRUE(unpremulFrame &&
               unpremulFrame->getStatus() == ImageFrame::FrameComplete);
   EXPECT_EQ(unpremulFrame->bitmap().alphaType(), kOpaque_SkAlphaType);
 }
 
 }  // namespace blink