Move gif image decoder to SkCodec

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 41 matching lines @@
                           ImageDecoder::kNoDecodedImageByteLimit));
 }
 
 void TestRepetitionCount(const char* dir,
                          const char* file,
                          int expected_repetition_count) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
   RefPtr<SharedBuffer> data = ReadFile(dir, file);
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
-  EXPECT_EQ(kAnimationLoopOnce,
-            decoder->RepetitionCount());  // Default value before decode.
 
-  for (size_t i = 0; i < decoder->FrameCount(); ++i) {
-    ImageFrame* frame = decoder->FrameBufferAtIndex(i);
-    EXPECT_EQ(ImageFrame::kFrameComplete, frame->GetStatus());
-  }
-
-  EXPECT_EQ(expected_repetition_count,
-            decoder->RepetitionCount());  // Expected value after decode.
+  EXPECT_EQ(expected_repetition_count, decoder->RepetitionCount());
 }
 
 }  // anonymous namespace
 
 TEST(GIFImageDecoderTest, decodeTwoFrames) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data = ReadFile(kLayoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
 
   ImageFrame* frame = decoder->FrameBufferAtIndex(0);
   uint32_t generation_id0 = frame->Bitmap().getGenerationID();
   EXPECT_EQ(ImageFrame::kFrameComplete, frame->GetStatus());
   EXPECT_EQ(16, frame->Bitmap().width());
   EXPECT_EQ(16, frame->Bitmap().height());
 
   frame = decoder->FrameBufferAtIndex(1);
   uint32_t generation_id1 = frame->Bitmap().getGenerationID();
   EXPECT_EQ(ImageFrame::kFrameComplete, frame->GetStatus());
   EXPECT_EQ(16, frame->Bitmap().width());
   EXPECT_EQ(16, frame->Bitmap().height());
   EXPECT_TRUE(generation_id0 != generation_id1);
 
   EXPECT_EQ(2u, decoder->FrameCount());
   EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(GIFImageDecoderTest, parseAndDecode) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data = ReadFile(kLayoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
-
-  // This call will parse the entire file.
-  EXPECT_EQ(2u, decoder->FrameCount());
 
   ImageFrame* frame = decoder->FrameBufferAtIndex(0);
   EXPECT_EQ(ImageFrame::kFrameComplete, frame->GetStatus());
   EXPECT_EQ(16, frame->Bitmap().width());
   EXPECT_EQ(16, frame->Bitmap().height());
 
   frame = decoder->FrameBufferAtIndex(1);
   EXPECT_EQ(ImageFrame::kFrameComplete, frame->GetStatus());
   EXPECT_EQ(16, frame->Bitmap().width());
   EXPECT_EQ(16, frame->Bitmap().height());
@@ skipping 84 matching lines @@
 TEST(GIFImageDecoderTest, frameIsCompleteLoading) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data_buffer =
       ReadFile(kLayoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data_buffer.Get());
   const Vector<char> data = data_buffer->Copy();
 
   ASSERT_GE(data.size(), 10u);
   RefPtr<SharedBuffer> temp_data =
-      SharedBuffer::Create(data.data(), data.size() - 10);
+      SharedBuffer::Create(data.data(), data.size() - 34);
   decoder->SetData(temp_data.Get(), false);
 
-  EXPECT_EQ(2u, decoder->FrameCount());
+  EXPECT_EQ(1u, decoder->FrameCount());
   EXPECT_FALSE(decoder->Failed());
   EXPECT_TRUE(decoder->FrameIsReceivedAtIndex(0));
   EXPECT_FALSE(decoder->FrameIsReceivedAtIndex(1));

[cblume, 2017/07/26 07:43:30]

You see how I updated to - 34 a few lines above? And changed the frame count to
1?
If you instead do - 33 then the second frame shows up in the frame count. BUT
the second frame is also marked with fFullyReceived = true.

So line 208 here fails the assertion as soon as the second frame is reported.
There is no instance where the second frame in this test is reported without
fFullyReceived being true.

 
   decoder->SetData(data_buffer.Get(), true);
   EXPECT_EQ(2u, decoder->FrameCount());
   EXPECT_TRUE(decoder->FrameIsReceivedAtIndex(0));
   EXPECT_TRUE(decoder->FrameIsReceivedAtIndex(1));
 }
 
 TEST(GIFImageDecoderTest, badTerminator) {
   RefPtr<SharedBuffer> reference_data =
       ReadFile(kDecodersTestingDir, "radient.gif");
@@ skipping 71 matching lines @@
       ReadFile(kDecodersTestingDir, "bad-code.gif");
   ASSERT_TRUE(test_data.Get());
 
   std::unique_ptr<ImageDecoder> test_decoder = CreateDecoder();
   test_decoder->SetData(test_data.Get(), true);
   EXPECT_EQ(1u, test_decoder->FrameCount());
   ASSERT_TRUE(test_decoder->FrameBufferAtIndex(0));
   EXPECT_TRUE(test_decoder->Failed());
 }
 
-TEST(GIFImageDecoderTest, invalidDisposalMethod) {
-  std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
-
-  // The image has 2 frames, with disposal method 4 and 5, respectively.
-  RefPtr<SharedBuffer> data =
-      ReadFile(kDecodersTestingDir, "invalid-disposal-method.gif");
-  ASSERT_TRUE(data.Get());
-  decoder->SetData(data.Get(), true);
-
-  EXPECT_EQ(2u, decoder->FrameCount());
-  // Disposal method 4 is converted to ImageFrame::DisposeOverwritePrevious.
-  EXPECT_EQ(ImageFrame::kDisposeOverwritePrevious,
-            decoder->FrameBufferAtIndex(0)->GetDisposalMethod());
-  // Disposal method 5 is ignored.
-  EXPECT_EQ(ImageFrame::kDisposeNotSpecified,
-            decoder->FrameBufferAtIndex(1)->GetDisposalMethod());
-}
-
 TEST(GIFImageDecoderTest, firstFrameHasGreaterSizeThanScreenSize) {
   const Vector<char> full_data =
       ReadFile(kDecodersTestingDir,
                "first-frame-has-greater-size-than-screen-size.gif")
           ->Copy();
 
   std::unique_ptr<ImageDecoder> decoder;
   IntSize frame_size;
 
   // Compute hashes when the file is truncated.
@@ skipping 43 matching lines @@
 
   // Partially decoded frame => the frame alpha type is unknown and should
   // reflect the requested format.
   premul_decoder->SetData(partial_data.Get(), false);
   ASSERT_TRUE(premul_decoder->FrameCount());
   unpremul_decoder->SetData(partial_data.Get(), false);
   ASSERT_TRUE(unpremul_decoder->FrameCount());
   ImageFrame* premul_frame = premul_decoder->FrameBufferAtIndex(0);
   EXPECT_TRUE(premul_frame &&
               premul_frame->GetStatus() != ImageFrame::kFrameComplete);
-  EXPECT_EQ(premul_frame->Bitmap().alphaType(), kPremul_SkAlphaType);
+  EXPECT_EQ(kPremul_SkAlphaType, premul_frame->Bitmap().alphaType());
   ImageFrame* unpremul_frame = unpremul_decoder->FrameBufferAtIndex(0);
   EXPECT_TRUE(unpremul_frame &&
               unpremul_frame->GetStatus() != ImageFrame::kFrameComplete);
-  EXPECT_EQ(unpremul_frame->Bitmap().alphaType(), kUnpremul_SkAlphaType);
+  EXPECT_EQ(kUnpremul_SkAlphaType, unpremul_frame->Bitmap().alphaType());
 
   // Fully decoded frame => the frame alpha type is known (opaque).
   premul_decoder->SetData(full_data_buffer.Get(), true);
   ASSERT_TRUE(premul_decoder->FrameCount());
   unpremul_decoder->SetData(full_data_buffer.Get(), true);
   ASSERT_TRUE(unpremul_decoder->FrameCount());
   premul_frame = premul_decoder->FrameBufferAtIndex(0);
   EXPECT_TRUE(premul_frame &&
               premul_frame->GetStatus() == ImageFrame::kFrameComplete);
-  EXPECT_EQ(premul_frame->Bitmap().alphaType(), kOpaque_SkAlphaType);
+  EXPECT_EQ(kOpaque_SkAlphaType, premul_frame->Bitmap().alphaType());
   unpremul_frame = unpremul_decoder->FrameBufferAtIndex(0);
   EXPECT_TRUE(unpremul_frame &&
               unpremul_frame->GetStatus() == ImageFrame::kFrameComplete);
-  EXPECT_EQ(unpremul_frame->Bitmap().alphaType(), kOpaque_SkAlphaType);
+  EXPECT_EQ(kOpaque_SkAlphaType, unpremul_frame->Bitmap().alphaType());
 }
 
 namespace {
 // Needed to exercise ImageDecoder::SetMemoryAllocator, but still does the
 // default allocation.
 class Allocator final : public SkBitmap::Allocator {
   bool allocPixelRef(SkBitmap* dst) override { return dst->tryAllocPixels(); }
 };
 }
 
@@ skipping 11 matching lines @@
   EXPECT_EQ(1u, decoder->FrameCount());
   ImageFrame* frame = decoder->FrameBufferAtIndex(0);
   decoder->SetMemoryAllocator(nullptr);
 
   ASSERT_TRUE(frame);
   EXPECT_EQ(IntRect(IntPoint(), decoder->Size()), frame->OriginalFrameRect());
   EXPECT_FALSE(frame->HasAlpha());
 }
 
 }  // namespace blink