Revert of Fix ImageAnimation constant names after Blink renaming

third_party/WebKit/Source/platform/image-decoders/webp/WEBPImageDecoderTest.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 57 matching lines @@
 
   if (parse_error_expected) {
     EXPECT_EQ(0u, decoder->FrameCount());
     EXPECT_FALSE(decoder->FrameBufferAtIndex(0));
   } else {
     EXPECT_GT(decoder->FrameCount(), 0u);
     ImageFrame* frame = decoder->FrameBufferAtIndex(0);
     ASSERT_TRUE(frame);
     EXPECT_EQ(ImageFrame::kFramePartial, frame->GetStatus());
   }
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopOnce, decoder->RepetitionCount());
   EXPECT_TRUE(decoder->Failed());
 }
 
 }  // anonymous namespace
 
 TEST(AnimatedWebPTests, uniqueGenerationIDs) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
   RefPtr<SharedBuffer> data =
       ReadFile("/LayoutTests/images/resources/webp-animated.webp");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
 
   ImageFrame* frame = decoder->FrameBufferAtIndex(0);
   uint32_t generation_id0 = frame->Bitmap().getGenerationID();
   frame = decoder->FrameBufferAtIndex(1);
   uint32_t generation_id1 = frame->Bitmap().getGenerationID();
 
   EXPECT_TRUE(generation_id0 != generation_id1);
 }
 
 TEST(AnimatedWebPTests, verifyAnimationParametersTransparentImage) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopOnce, decoder->RepetitionCount());
 
   RefPtr<SharedBuffer> data =
       ReadFile("/LayoutTests/images/resources/webp-animated.webp");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
 
   const int kCanvasWidth = 11;
   const int kCanvasHeight = 29;
   const struct AnimParam {
     int x_offset, y_offset, width, height;
@@ skipping 20 matching lines @@
     EXPECT_EQ(kFrameParameters[i].width, frame->OriginalFrameRect().Width());
     EXPECT_EQ(kFrameParameters[i].height, frame->OriginalFrameRect().Height());
     EXPECT_EQ(kFrameParameters[i].disposal_method, frame->GetDisposalMethod());
     EXPECT_EQ(kFrameParameters[i].alpha_blend_source,
               frame->GetAlphaBlendSource());
     EXPECT_EQ(kFrameParameters[i].duration, frame->Duration());
     EXPECT_EQ(kFrameParameters[i].has_alpha, frame->HasAlpha());
   }
 
   EXPECT_EQ(WTF_ARRAY_LENGTH(kFrameParameters), decoder->FrameCount());
-  EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(AnimatedWebPTests,
      verifyAnimationParametersOpaqueFramesTransparentBackground) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopOnce, decoder->RepetitionCount());
 
   RefPtr<SharedBuffer> data =
       ReadFile("/LayoutTests/images/resources/webp-animated-opaque.webp");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
 
   const int kCanvasWidth = 94;
   const int kCanvasHeight = 87;
   const struct AnimParam {
     int x_offset, y_offset, width, height;
@@ skipping 22 matching lines @@
     EXPECT_EQ(kFrameParameters[i].width, frame->OriginalFrameRect().Width());
     EXPECT_EQ(kFrameParameters[i].height, frame->OriginalFrameRect().Height());
     EXPECT_EQ(kFrameParameters[i].disposal_method, frame->GetDisposalMethod());
     EXPECT_EQ(kFrameParameters[i].alpha_blend_source,
               frame->GetAlphaBlendSource());
     EXPECT_EQ(kFrameParameters[i].duration, frame->Duration());
     EXPECT_EQ(kFrameParameters[i].has_alpha, frame->HasAlpha());
   }
 
   EXPECT_EQ(WTF_ARRAY_LENGTH(kFrameParameters), decoder->FrameCount());
-  EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(AnimatedWebPTests, verifyAnimationParametersBlendOverwrite) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopOnce, decoder->RepetitionCount());
 
   RefPtr<SharedBuffer> data =
       ReadFile("/LayoutTests/images/resources/webp-animated-no-blend.webp");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
 
   const int kCanvasWidth = 94;
   const int kCanvasHeight = 87;
   const struct AnimParam {
     int x_offset, y_offset, width, height;
@@ skipping 22 matching lines @@
     EXPECT_EQ(kFrameParameters[i].width, frame->OriginalFrameRect().Width());
     EXPECT_EQ(kFrameParameters[i].height, frame->OriginalFrameRect().Height());
     EXPECT_EQ(kFrameParameters[i].disposal_method, frame->GetDisposalMethod());
     EXPECT_EQ(kFrameParameters[i].alpha_blend_source,
               frame->GetAlphaBlendSource());
     EXPECT_EQ(kFrameParameters[i].duration, frame->Duration());
     EXPECT_EQ(kFrameParameters[i].has_alpha, frame->HasAlpha());
   }
 
   EXPECT_EQ(WTF_ARRAY_LENGTH(kFrameParameters), decoder->FrameCount());
-  EXPECT_EQ(kAnimationLoopInfinite, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopInfinite, decoder->RepetitionCount());
 }
 
 TEST(AnimatedWebPTests, parseAndDecodeByteByByte) {
   TestByteByByteDecode(&CreateDecoder,
                        "/LayoutTests/images/resources/webp-animated.webp", 3u,
-                       kAnimationLoopInfinite);
+                       kCAnimationLoopInfinite);
   TestByteByByteDecode(
       &CreateDecoder,
       "/LayoutTests/images/resources/webp-animated-icc-xmp.webp", 13u, 32000);
 }
 
 TEST(AnimatedWebPTests, invalidImages) {
   // ANMF chunk size is smaller than ANMF header size.
   TestInvalidImage("/LayoutTests/images/resources/invalid-animated-webp.webp",
                    true);
   // One of the frame rectangles extends outside the image boundary.
@@ skipping 63 matching lines @@
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::kFramePartial, frame->GetStatus());
   EXPECT_FALSE(decoder->Failed());
 
   // Parse full data now. The error in bitstream should now be detected.
   decoder->SetData(full_data.Get(), true);
   EXPECT_EQ(1u, decoder->FrameCount());
   frame = decoder->FrameBufferAtIndex(0);
   ASSERT_TRUE(frame);
   EXPECT_EQ(ImageFrame::kFramePartial, frame->GetStatus());
-  EXPECT_EQ(kAnimationLoopOnce, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationLoopOnce, decoder->RepetitionCount());
   EXPECT_TRUE(decoder->Failed());
 }
 
 TEST(AnimatedWebPTests, progressiveDecode) {
   TestProgressiveDecoding(&CreateDecoder,
                           "/LayoutTests/images/resources/webp-animated.webp");
 }
 
 TEST(AnimatedWebPTests, frameIsCompleteAndDuration) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
@@ skipping 84 matching lines @@
       &CreateDecoder,
       "/LayoutTests/images/resources/webp-animated-semitransparent3.webp");
   TestAlphaBlending(
       &CreateDecoder,
       "/LayoutTests/images/resources/webp-animated-semitransparent4.webp");
 }
 
 TEST(AnimatedWebPTests, isSizeAvailable) {
   TestByteByByteSizeAvailable(
       &CreateDecoder, "/LayoutTests/images/resources/webp-animated.webp", 142u,
-      false, kAnimationLoopInfinite);
+      false, kCAnimationLoopInfinite);
   // FIXME: Add color profile support for animated webp images.
   TestByteByByteSizeAvailable(
       &CreateDecoder,
       "/LayoutTests/images/resources/webp-animated-icc-xmp.webp", 1404u, false,
       32000);
 }
 
 TEST(AnimatedWEBPTests, clearCacheExceptFrameWithAncestors) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
 
@@ skipping 75 matching lines @@
   TestInvalidImage("/LayoutTests/images/resources/truncated.webp", false);
   // Chunk size in RIFF header doesn't match the file size.
   TestInvalidImage("/LayoutTests/images/resources/truncated2.webp", true);
 }
 
 // Regression test for a bug where some valid images were failing to decode
 // incrementally.
 TEST(StaticWebPTests, incrementalDecode) {
   TestByteByByteDecode(&CreateDecoder,
                        "/LayoutTests/images/resources/crbug.364830.webp", 1u,
-                       kAnimationNone);
+                       kCAnimationNone);
 }
 
 TEST(StaticWebPTests, isSizeAvailable) {
   TestByteByByteSizeAvailable(
       &CreateDecoder,
       "/LayoutTests/images/resources/webp-color-profile-lossy.webp", 520u, true,
-      kAnimationNone);
+      kCAnimationNone);
   TestByteByByteSizeAvailable(&CreateDecoder,
                               "/LayoutTests/images/resources/test.webp", 30u,
-                              false, kAnimationNone);
+                              false, kCAnimationNone);
 }
 
 TEST(StaticWebPTests, notAnimated) {
   std::unique_ptr<ImageDecoder> decoder = CreateDecoder();
   RefPtr<SharedBuffer> data =
       ReadFile("/LayoutTests/images/resources/webp-color-profile-lossy.webp");
   ASSERT_TRUE(data.Get());
   decoder->SetData(data.Get(), true);
   EXPECT_EQ(1u, decoder->FrameCount());
-  EXPECT_EQ(kAnimationNone, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationNone, decoder->RepetitionCount());
 }
 
 }  // namespace blink