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 182 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