Add tests for PNGImageDecoder.

third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoderTest.cpp

+// Copyright 2016 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 "platform/image-decoders/png/PNGImageDecoder.h"
+
+#include "platform/image-decoders/ImageDecoderTestHelpers.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include <memory>
+
+namespace blink {
+
+namespace {
+
+std::unique_ptr<ImageDecoder> createDecoder(
+    ImageDecoder::AlphaOption alphaOption) {
+  return wrapUnique(
+      new PNGImageDecoder(alphaOption, ImageDecoder::ColorSpaceTransformed,
+                          ImageDecoder::targetColorSpaceForTesting(),
+                          ImageDecoder::noDecodedImageByteLimit));
+}
+
+std::unique_ptr<ImageDecoder> createDecoder() {
+  return createDecoder(ImageDecoder::AlphaNotPremultiplied);
+}
+
+std::unique_ptr<ImageDecoder> createDecoderWithPngData(const char* pngFile) {
+  auto decoder = createDecoder();
+  auto data = readFile(pngFile);
+  EXPECT_FALSE(data->isEmpty());
+  decoder->setData(data.get(), true);
+  return decoder;
+}
+
+void testSize(const char* pngFile, IntSize expectedSize) {
+  auto decoder = createDecoderWithPngData(pngFile);
+  EXPECT_TRUE(decoder->isSizeAvailable());
+  EXPECT_EQ(expectedSize, decoder->size());
+}
+
+void testRepetitionCount(const char* pngFile, int expectedRepetitionCount) {
+  auto decoder = createDecoderWithPngData(pngFile);
+  // Decoding the frame count sets the repetition count as well.
+  decoder->frameCount();
+  EXPECT_FALSE(decoder->failed());
+  EXPECT_EQ(expectedRepetitionCount, decoder->repetitionCount());
+}
+
+// Verify that the decoder can successfully decode the first frame when
+// initially only half of the frame data is received, resulting in a partially
+// decoded image, and then the rest of the image data is received. Verify that
+// the bitmap hashes of the two stages are different. Also verify that the final
+// bitmap hash is equivalent to the hash when all data is provided at once.
+//
+// This verifies that decoder correctly keeps track of where it stopped
+// decoding when the image was not yet fully received.
+void testProgressiveDecodingContinuesAfterFullData(const char* pngFile,
+                                                   size_t offsetMidFirstFrame) {
+  auto fullData = readFile(pngFile);
+  ASSERT_FALSE(fullData->isEmpty());
+
+  auto decoderUpfront = createDecoder();
+  decoderUpfront->setData(fullData.get(), true);
+  EXPECT_GE(1u, decoderUpfront->frameCount());
+  const ImageFrame* const frameUpfront = decoderUpfront->frameBufferAtIndex(0);
+  ASSERT_EQ(ImageFrame::FrameComplete, frameUpfront->getStatus());
+  const unsigned hashUpfront = hashBitmap(frameUpfront->bitmap());
+
+  auto decoder = createDecoder();
+  RefPtr<SharedBuffer> partialData =
+      SharedBuffer::create(fullData->data(), offsetMidFirstFrame);
+  decoder->setData(partialData, false);
+
+  EXPECT_EQ(1u, decoder->frameCount());
+  const ImageFrame* frame = decoder->frameBufferAtIndex(0);
+  EXPECT_EQ(frame->getStatus(), ImageFrame::FramePartial);
+  const unsigned hashPartial = hashBitmap(frame->bitmap());
+
+  decoder->setData(fullData.get(), true);
+  frame = decoder->frameBufferAtIndex(0);
+  EXPECT_EQ(frame->getStatus(), ImageFrame::FrameComplete);
+  const unsigned hashFull = hashBitmap(frame->bitmap());
+
+  EXPECT_FALSE(decoder->failed());
+  EXPECT_NE(hashFull, hashPartial);
+  EXPECT_EQ(hashFull, hashUpfront);
+}
+
+// Modify the frame data bytes for frame |frameIndex| so that decoding fails.
+// Parsing should work fine, and is checked with |expectedFrameCountBefore|. If
+// the failure should invalidate the decoder, |expectFailure| should be set to
+// true. If not, |expectedFrameCountAfter| should indicate the new frame count
+// after the failure.
+void testFailureDuringDecode(const char* file,
+                             size_t idatOffset,
+                             size_t frameIndex,
+                             bool expectFailure,
+                             size_t expectedFrameCountBefore,
+                             size_t expectedFrameCountAfter = 0u) {
+  RefPtr<SharedBuffer> fullData = readFile(file);
+  ASSERT_FALSE(fullData->isEmpty());
+
+  // This is the offset where the frame data chunk frame |frameIndex| starts.
+  RefPtr<SharedBuffer> data =
+      SharedBuffer::create(fullData->data(), idatOffset + 8u);
+  // Repeat the first 8 bytes of the frame data. This should result in a
+  // successful parse, since frame data is not analyzed in that step, but
+  // should give an error during decoding.
+  data->append(fullData->data() + idatOffset, 8u);
+  data->append(fullData->data() + idatOffset + 16u,
+               fullData->size() - idatOffset - 16u);
+
+  auto decoder = createDecoder();
+  decoder->setData(data.get(), true);
+
+  EXPECT_EQ(expectedFrameCountBefore, decoder->frameCount());
+
+  const ImageFrame* const frame = decoder->frameBufferAtIndex(frameIndex);
+  EXPECT_EQ(expectFailure, decoder->failed());
+  if (!expectFailure) {
+    EXPECT_EQ(expectedFrameCountAfter, decoder->frameCount());
+    EXPECT_EQ(ImageFrame::FrameEmpty, frame->getStatus());
+  }
+}
+
+}  // Anonymous namespace
+
+// Static PNG tests
+
+TEST(StaticPNGTests, repetitionCountTest) {
+  testRepetitionCount("/LayoutTests/images/resources/png-simple.png",
+                      cAnimationNone);
+}
+
+TEST(StaticPNGTests, sizeTest) {
+  testSize("/LayoutTests/images/resources/png-simple.png", IntSize(111, 29));
+}
+
+TEST(StaticPNGTests, MetaDataTest) {
+  const size_t expectedFrameCount = 1;
+  const size_t expectedDuration = 0;
+  auto decoder =
+      createDecoderWithPngData("/LayoutTests/images/resources/png-simple.png");
+  EXPECT_EQ(expectedFrameCount, decoder->frameCount());
+  EXPECT_EQ(expectedDuration, decoder->frameDurationAtIndex(0));
+}
+
+TEST(StaticPNGTests, ProgressiveDecoding) {
+  testProgressiveDecoding(&createDecoder,
+                          "/LayoutTests/images/resources/png-simple.png", 11u);
+}
+
+TEST(StaticPNGTests, ProgressiveDecodingContinuesAfterFullData) {
+  testProgressiveDecodingContinuesAfterFullData(
+      "/LayoutTests/images/resources/png-simple.png", 1000u);
+}
+
+TEST(StaticPNGTests, FailureDuringDecodingInvalidatesDecoder) {
+  testFailureDuringDecode(
+      "/LayoutTests/images/resources/png-simple.png",
+      85u,   // idat offset for frame index 0
+      0u,    // try to decode frame index 0
+      true,  // expect the decoder to be invalidated after the failure
+      1u);   // expected frame count before failure
+}
+
+// For static images, frameIsCompleteAtIndex(0) should return true if and only
+// if the frame is successfully decoded, not when it is fully received.
+TEST(StaticPNGTests, VerifyFrameCompleteBehavior) {
+  auto decoder =
+      createDecoderWithPngData("/LayoutTests/images/resources/png-simple.png");
+  EXPECT_EQ(1u, decoder->frameCount());
+  EXPECT_FALSE(decoder->frameIsCompleteAtIndex(0));
+  EXPECT_EQ(ImageFrame::FrameComplete,
+            decoder->frameBufferAtIndex(0)->getStatus());
+  EXPECT_TRUE(decoder->frameIsCompleteAtIndex(0));
+}
+
+};  // namespace blink