Revert of Fix ImageAnimation constant names after Blink renaming

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 <memory>
 #include "platform/image-decoders/ImageDecoderTestHelpers.h"
 #include "png.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 153 matching lines @@
 
 // Verify that a decoder with a parse error converts to a static image.
 static void ExpectStatic(ImageDecoder* decoder) {
   EXPECT_EQ(1u, decoder->FrameCount());
   EXPECT_FALSE(decoder->Failed());
 
   ImageFrame* frame = decoder->FrameBufferAtIndex(0);
   ASSERT_NE(nullptr, frame);
   EXPECT_EQ(ImageFrame::kFrameComplete, frame->GetStatus());
   EXPECT_FALSE(decoder->Failed());
-  EXPECT_EQ(kAnimationNone, decoder->RepetitionCount());
+  EXPECT_EQ(kCAnimationNone, decoder->RepetitionCount());
 }
 
 // Decode up to the indicated fcTL offset and then provide an fcTL with the
 // wrong chunk size (20 instead of 26).
 void TestInvalidFctlSize(const char* png_file,
                          size_t offset_fctl,
                          size_t expected_frame_count,
                          bool should_fail) {
   auto data = ReadFile(png_file);
   ASSERT_FALSE(data->IsEmpty());
@@ skipping 120 matching lines @@
   TestRepetitionCount(
       "/LayoutTests/images/resources/"
       "png-animated-idat-part-of-animation.png",
       6u);
   // This is an "animated" image with only one frame, that is, the IDAT is
   // ignored and there is one fdAT frame. so it should be considered
   // non-animated.
   TestRepetitionCount(
       "/LayoutTests/images/resources/"
       "png-animated-idat-not-part-of-animation.png",
-      kAnimationNone);
+      kCAnimationNone);
 }
 
 // Test if the decoded metdata corresponds to the defined expectations
 TEST(AnimatedPNGTests, MetaDataTest) {
   const char* png_file =
       "/LayoutTests/images/resources/"
       "png-animated-idat-part-of-animation.png";
   constexpr size_t kExpectedFrameCount = 4;
 
   auto decoder = CreateDecoderWithPngData(png_file);
@@ skipping 123 matching lines @@
     // Remove the acTL chunk from the stream. This results in a static image.
     RefPtr<SharedBuffer> no_actl_data =
         SharedBuffer::Create(data->Data(), kOffsetActl);
     no_actl_data->Append(data->Data() + kOffsetActl + kAcTLSize,
                          data->size() - kOffsetActl - kAcTLSize);
 
     auto decoder = CreateDecoder();
     decoder->SetData(no_actl_data, true);
     EXPECT_EQ(1u, decoder->FrameCount());
     EXPECT_FALSE(decoder->Failed());
-    EXPECT_EQ(kAnimationNone, decoder->RepetitionCount());
+    EXPECT_EQ(kCAnimationNone, decoder->RepetitionCount());
   }
 
   // Store the acTL for more tests.
   char ac_tl[kAcTLSize];
   memcpy(ac_tl, data->Data() + kOffsetActl, kAcTLSize);
 
   // Insert an extra acTL at a couple of different offsets.
   // Prior to the IDAT, this should result in a static image. After, this
   // should fail.
   const struct {
@@ skipping 29 matching lines @@
           SharedBuffer::Create(data2->Data(), kPostIDATOffset);
       for (size_t i = 0; i < times; i++)
         extra_actl_data->Append(ac_tl, kAcTLSize);
       extra_actl_data->Append(data2->Data() + kPostIDATOffset,
                               data2->size() - kPostIDATOffset);
 
       auto decoder = CreateDecoder();
       decoder->SetData(extra_actl_data, true);
       EXPECT_EQ(1u, decoder->FrameCount());
       EXPECT_FALSE(decoder->Failed());
-      EXPECT_EQ(kAnimationNone, decoder->RepetitionCount());
+      EXPECT_EQ(kCAnimationNone, decoder->RepetitionCount());
       EXPECT_NE(nullptr, decoder->FrameBufferAtIndex(0));
       EXPECT_FALSE(decoder->Failed());
     }
   }
 }
 
 TEST(AnimatedPNGTests, fdatBeforeIdat) {
   const char* png_file =
       "/LayoutTests/images/resources/"
       "png-animated-idat-not-part-of-animation.png";
@@ skipping 409 matching lines @@
   data->Append(reinterpret_cast<const char*>(fc_tl), kFcTLSize);
 
   // Append the rest of the data.
   // Note: If PNGImageDecoder changes to reject an image with too many
   // rows, the fdAT data will need to be modified as well.
   data->Append(original_data->Data() + kFcTLOffset + kFcTLSize,
                original_data->size() - data->size());
   ASSERT_EQ(original_data->size(), data->size());
 
   // This will test both byte by byte and using the full data, and compare.
-  TestByteByByteDecode(CreateDecoder, data.Get(), 1, kAnimationNone);
+  TestByteByByteDecode(CreateDecoder, data.Get(), 1, kCAnimationNone);
 }
 
 // Static PNG tests
 
 TEST(StaticPNGTests, repetitionCountTest) {
   TestRepetitionCount("/LayoutTests/images/resources/png-simple.png",
-                      kAnimationNone);
+                      kCAnimationNone);
 }
 
 TEST(StaticPNGTests, sizeTest) {
   TestSize("/LayoutTests/images/resources/png-simple.png", IntSize(111, 29));
 }
 
 TEST(StaticPNGTests, MetaDataTest) {
   const size_t kExpectedFrameCount = 1;
   const size_t kExpectedDuration = 0;
   auto decoder =
@@ skipping 93 matching lines @@
 }
 
 TEST(PNGTests, sizeMayOverflow) {
   auto decoder =
       CreateDecoderWithPngData("/LayoutTests/images/resources/crbug702934.png");
   EXPECT_FALSE(decoder->IsSizeAvailable());
   EXPECT_TRUE(decoder->Failed());
 }
 
 };  // namespace blink