Revert of Fix ImageAnimation constant names after Blink renaming

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,
+  EXPECT_EQ(kCAnimationLoopOnce,
             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.
 }
 
 }  // 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());
+  EXPECT_EQ(kCAnimationLoopOnce, 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());
+  EXPECT_EQ(kCAnimationLoopInfinite, 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());
+  EXPECT_EQ(kCAnimationLoopOnce, 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());
-  EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(GIFImageDecoderTest, parseByteByByte) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data = ReadFile(kLayoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.Get());
 
   size_t frame_count = 0;
 
   // Pass data to decoder byte by byte.
   for (size_t length = 1; length <= data->size(); ++length) {
     RefPtr<SharedBuffer> temp_data = SharedBuffer::Create(data->Data(), length);
     decoder->SetData(temp_data.Get(), length == data->size());
 
     EXPECT_LE(frame_count, decoder->FrameCount());
     frame_count = decoder->FrameCount();
   }
 
   EXPECT_EQ(2u, decoder->FrameCount());
 
   decoder->FrameBufferAtIndex(0);
   decoder->FrameBufferAtIndex(1);
-  EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(GIFImageDecoderTest, parseAndDecodeByteByByte) {
   TestByteByByteDecode(&CreateDecoder, kLayoutTestResourcesDir,
                        "animated-gif-with-offsets.gif", 5u,
-                       kAnimationLoopInfinite);
+                       kCAnimationLoopInfinite);
 }
 
 TEST(GIFImageDecoderTest, brokenSecondFrame) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data = ReadFile(kDecodersTestingDir, "broken.gif");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
 
   // One frame is detected but cannot be decoded.
@@ skipping 30 matching lines @@
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data = ReadFile(kLayoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
 
   EXPECT_EQ(2u, decoder->FrameCount());
   EXPECT_FALSE(decoder->Failed());
   EXPECT_TRUE(decoder->FrameIsCompleteAtIndex(0));
   EXPECT_TRUE(decoder->FrameIsCompleteAtIndex(1));
-  EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(GIFImageDecoderTest, frameIsCompleteLoading) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data = ReadFile(kLayoutTestResourcesDir, "animated.gif");
   ASSERT_TRUE(data.Get());
 
   ASSERT_GE(data->size(), 10u);
   RefPtr<SharedBuffer> temp_data =
@@ skipping 133 matching lines @@
       continue;
     }
 
     ASSERT_EQ(frame_size.Width(), decoder->DecodedSize().Width());
     ASSERT_EQ(frame_size.Height(), decoder->DecodedSize().Height());
   }
 }
 
 TEST(GIFImageDecoderTest, verifyRepetitionCount) {
   TestRepetitionCount(kLayoutTestResourcesDir, "full2loop.gif", 2);
-  TestRepetitionCount(kDecodersTestingDir, "radient.gif", kAnimationNone);
+  TestRepetitionCount(kDecodersTestingDir, "radient.gif", kCAnimationNone);
 }
 
 TEST(GIFImageDecoderTest, bitmapAlphaType) {
   RefPtr<SharedBuffer> full_data = ReadFile(kDecodersTestingDir, "radient.gif");
   ASSERT_TRUE(full_data.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 64 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