Revert of Fix ImageAnimation constant names after Blink renaming

third_party/WebKit/Source/platform/graphics/BitmapImage.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 62 matching lines @@
     : Image(observer),
       current_frame_(0),
       cached_frame_index_(0),
       animation_policy_(kImageAnimationPolicyAllowed),
       animation_finished_(false),
       all_data_received_(false),
       have_size_(false),
       size_available_(false),
       have_frame_count_(false),
       repetition_count_status_(kUnknown),
-      repetition_count_(kAnimationNone),
+      repetition_count_(kCAnimationNone),
       repetitions_complete_(0),
       desired_frame_start_time_(0),
       frame_count_(0) {}
 
 BitmapImage::BitmapImage(const SkBitmap& bitmap, ImageObserver* observer)
     : Image(observer),
       size_(bitmap.width(), bitmap.height()),
       current_frame_(0),
       cached_frame_(SkImage::MakeFromBitmap(bitmap)),
       cached_frame_index_(0),
       animation_policy_(kImageAnimationPolicyAllowed),
       animation_finished_(true),
       all_data_received_(true),
       have_size_(true),
       size_available_(true),
       have_frame_count_(true),
       repetition_count_status_(kUnknown),
-      repetition_count_(kAnimationNone),
+      repetition_count_(kCAnimationNone),
       repetitions_complete_(0),
       frame_count_(1) {
   // Since we don't have a decoder, we can't figure out the image orientation.
   // Set m_sizeRespectingOrientation to be the same as m_size so it's not 0x0.
   size_respecting_orientation_ = size_;
 
   frames_.Grow(1);
   frames_[0].has_alpha_ = !bitmap.isOpaque();
   frames_[0].have_metadata_ = true;
 }
@@ skipping 39 matching lines @@
   // We are caching frame snapshots.  This is OK even for partially decoded
   // frames, as they are cleared by dataChanged() when new data arrives.
   sk_sp<SkImage> image =
       source_.CreateFrameAtIndex(index, DefaultColorBehavior());
   cached_frame_ = image;
   cached_frame_index_ = index;
 
   frames_[index].orientation_ = source_.OrientationAtIndex(index);
   frames_[index].have_metadata_ = true;
   frames_[index].is_complete_ = source_.FrameIsCompleteAtIndex(index);
-  if (RepetitionCount(false) != kAnimationNone)
+  if (RepetitionCount(false) != kCAnimationNone)
     frames_[index].duration_ = source_.FrameDurationAtIndex(index);
   frames_[index].has_alpha_ = source_.FrameHasAlphaAtIndex(index);
   frames_[index].frame_bytes_ = source_.FrameBytesAtIndex(index);
 
   NotifyMemoryChanged();
   return image;
 }
 
 void BitmapImage::UpdateSize() const {
   if (!size_available_ || have_size_)
@@ skipping 262 matching lines @@
 int BitmapImage::RepetitionCount(bool image_known_to_be_complete) {
   if ((repetition_count_status_ == kUnknown) ||
       ((repetition_count_status_ == kUncertain) &&
        image_known_to_be_complete)) {
     // Snag the repetition count.  If |imageKnownToBeComplete| is false, the
     // repetition count may not be accurate yet for GIFs; in this case the
     // decoder will default to cAnimationLoopOnce, and we'll try and read
     // the count again once the whole image is decoded.
     repetition_count_ = source_.RepetitionCount();
     repetition_count_status_ =
-        (image_known_to_be_complete || repetition_count_ == kAnimationNone)
+        (image_known_to_be_complete || repetition_count_ == kCAnimationNone)
             ? kCertain
             : kUncertain;
   }
   return repetition_count_;
 }
 
 bool BitmapImage::ShouldAnimate() {
-  bool animated = RepetitionCount(false) != kAnimationNone &&
+  bool animated = RepetitionCount(false) != kCAnimationNone &&
                   !animation_finished_ && GetImageObserver();
   if (animated && animation_policy_ == kImageAnimationPolicyNoAnimation)
     animated = false;
   return animated;
 }
 
 void BitmapImage::StartAnimation(CatchUpAnimation catch_up_if_necessary) {
   if (frame_timer_ || !ShouldAnimate() || FrameCount() <= 1)
     return;
 
   // If we aren't already animating, set now as the animation start time.
   const double time = MonotonicallyIncreasingTime();
   if (!desired_frame_start_time_)
     desired_frame_start_time_ = time;
 
   // Don't advance the animation to an incomplete frame.
   size_t next_frame = (current_frame_ + 1) % FrameCount();
   if (!all_data_received_ && !FrameIsCompleteAtIndex(next_frame))
     return;
 
   // Don't advance past the last frame if we haven't decoded the whole image
   // yet and our repetition count is potentially unset.  The repetition count
   // in a GIF can potentially come after all the rest of the image data, so
   // wait on it.
   if (!all_data_received_ &&
-      (RepetitionCount(false) == kAnimationLoopOnce ||
+      (RepetitionCount(false) == kCAnimationLoopOnce ||
        animation_policy_ == kImageAnimationPolicyAnimateOnce) &&
       current_frame_ >= (FrameCount() - 1))
     return;
 
   // Determine time for next frame to start.  By ignoring paint and timer lag
   // in this calculation, we make the animation appear to run at its desired
   // rate regardless of how fast it's being repainted.
   const double current_duration = FrameDurationAtIndex(current_frame_);
   desired_frame_start_time_ += current_duration;
 
@@ skipping 72 matching lines @@
   animation_finished_ = false;
   cached_frame_.reset();
 }
 
 bool BitmapImage::MaybeAnimated() {
   if (animation_finished_)
     return false;
   if (FrameCount() > 1)
     return true;
 
-  return source_.RepetitionCount() != kAnimationNone;
+  return source_.RepetitionCount() != kCAnimationNone;
 }
 
 void BitmapImage::AdvanceTime(double delta_time_in_seconds) {
   if (desired_frame_start_time_)
     desired_frame_start_time_ -= delta_time_in_seconds;
   else
     desired_frame_start_time_ =
         MonotonicallyIncreasingTime() - delta_time_in_seconds;
 }
 
@@ skipping 23 matching lines @@
   if (current_frame_ + 1 < FrameCount()) {
     current_frame_++;
   } else {
     repetitions_complete_++;
 
     // Get the repetition count again. If we weren't able to get a
     // repetition count before, we should have decoded the whole image by
     // now, so it should now be available.
     // We don't need to special-case cAnimationLoopOnce here because it is
     // 0 (see comments on its declaration in ImageAnimation.h).
-    if ((RepetitionCount(true) != kAnimationLoopInfinite &&
+    if ((RepetitionCount(true) != kCAnimationLoopInfinite &&
          repetitions_complete_ > repetition_count_) ||
         animation_policy_ == kImageAnimationPolicyAnimateOnce) {
       animation_finished_ = true;
       desired_frame_start_time_ = 0;
 
       // We skipped to the last frame and cannot advance further. The
       // observer will not receive animationAdvanced notifications while
       // skipping but we still need to notify the observer to draw the
       // last frame. Skipping frames occurs while painting so we do not
       // synchronously notify the observer which could cause a layout.
@@ skipping 15 matching lines @@
     GetImageObserver()->AnimationAdvanced(this);
 
   return true;
 }
 
 void BitmapImage::NotifyObserversOfAnimationAdvance(TimerBase*) {
   GetImageObserver()->AnimationAdvanced(this);
 }
 
 }  // namespace blink