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 19 matching lines @@
 
 #include "platform/image-decoders/gif/GIFImageDecoder.h"
 
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoderTestHelpers.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebSize.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
+#include "wtf/text/StringBuilder.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
+const char* concatDirAndFile(const char* dir, const char* file) {
+  StringBuilder filePath;
+  filePath.append(dir);
+  filePath.append('/');
+  filePath.append(file);
+  return reinterpret_cast<const char*>(filePath.characters8());

[scroggo_chromium, 2016/11/10 17:34:39]

I missed this in patch set 2, where I think we have a similar issue, even though
we're using a different class:

characters8() returns a pointer to memory internal to the StringBuilder
filePath. When this method returns, filePath's destructor will get called.
You're getting "lucky" when you run the test, and the memory hasn't been cleaned
up, so it still looks like what you expect. (I say "lucky" because it'd be even
luckier for it to crash, so you didn't accidentally check this in!)

There's already a readFile method that concats a directory with a file. I
suggest you make testProgressiveDecoding (and others) take a SharedBuffer
parameter (possibly PassRefPtr<SharedBuffer> - I don't remember the current
proper Blink way to pass a ref-counted object; I think PassRefPtr may have gone
away...). To make the call sites simpler, you can make the SharedBuffer version
private to ImageDecoderTestHelpers.cpp, and provide two public versions - one
takes two parameters (dir, file), and the other takes one. *Or* you can have one
version where the dir can be set to nullptr (possibly even as a default
parameter, although then it would come last, which might be awkward since they'd
be in reverse logical order). (Another version is the null dir version gets
called by a public version that takes one param for the file name.)

[joostouwerling, 2016/11/10 23:47:18]

Done. From what I've seen in e.g. [1] it is fine to pass a raw pointer to a
SharedBuffer. This is also in line with the "modern" C++ approach that a naked
pointer implies that you shouldn't take ownership of it.

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...

+}
+
 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,
+                          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