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,
+                         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, 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, decodersTestingDir, "radient.gif");
   // Multiple frame images.
-  testRandomFrameDecode(layoutTestResourcesDir,
+  testRandomFrameDecode(&createDecoder, layoutTestResourcesDir,
                         "animated-gif-with-offsets.gif");
-  testRandomFrameDecode(layoutTestResourcesDir, "animated-10color.gif");
+  testRandomFrameDecode(&createDecoder, layoutTestResourcesDir,
+                        "animated-10color.gif");
 }
 
 TEST(GIFImageDecoderTest, randomDecodeAfterClearFrameBufferCache) {
   // Single frame image.
-  testRandomDecodeAfterClearFrameBufferCache(decodersTestingDir, "radient.gif");
+  testRandomDecodeAfterClearFrameBufferCache(&createDecoder, decodersTestingDir,
+                                             "radient.gif");
   // Multiple frame images.
-  testRandomDecodeAfterClearFrameBufferCache(layoutTestResourcesDir,
-                                             "animated-gif-with-offsets.gif");
-  testRandomDecodeAfterClearFrameBufferCache(layoutTestResourcesDir,
-                                             "animated-10color.gif");
+  testRandomDecodeAfterClearFrameBufferCache(
+      &createDecoder, layoutTestResourcesDir, "animated-gif-with-offsets.gif");
+  testRandomDecodeAfterClearFrameBufferCache(
+      &createDecoder, 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