FrameIsCompleteAtIndex to FrameIsReceivedAtIndex

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 136 matching lines @@
     frames_.Grow(num_frames);
 
   // 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);
   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);
+  frames_[index].is_complete_ = source_.FrameIsReceivedAtIndex(index);
   if (RepetitionCount(false) != kAnimationNone)
     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 {
@@ skipping 174 matching lines @@
 sk_sp<SkImage> BitmapImage::FrameAtIndex(size_t index) {
   if (index >= FrameCount())
     return nullptr;
 
   if (index == cached_frame_index_ && cached_frame_)
     return cached_frame_;
 
   return DecodeAndCacheFrame(index);
 }
 
-bool BitmapImage::FrameIsCompleteAtIndex(size_t index) const {
+bool BitmapImage::FrameIsReceivedAtIndex(size_t index) const {
   if (index < frames_.size() && frames_[index].have_metadata_ &&
       frames_[index].is_complete_)
     return true;
 
-  return source_.FrameIsCompleteAtIndex(index);
+  return source_.FrameIsReceivedAtIndex(index);
 }
 
 float BitmapImage::FrameDurationAtIndex(size_t index) const {
   if (index < frames_.size() && frames_[index].have_metadata_)
     return frames_[index].duration_;
 
   return source_.FrameDurationAtIndex(index);
 }
 
 sk_sp<SkImage> BitmapImage::ImageForCurrentFrame() {
@@ skipping 31 matching lines @@
   if (metadata_mode == kPreCacheMetadata) {
     // frameHasAlphaAtIndex() conservatively returns false for uncached frames.
     // To increase the chance of an accurate answer, pre-cache the current frame
     // metadata.
     FrameAtIndex(CurrentFrame());
   }
   return !FrameHasAlphaAtIndex(CurrentFrame());
 }
 
 bool BitmapImage::CurrentFrameIsComplete() {
-  return FrameIsCompleteAtIndex(CurrentFrame());
+  return FrameIsReceivedAtIndex(CurrentFrame());
 }
 
 bool BitmapImage::CurrentFrameIsLazyDecoded() {
   sk_sp<SkImage> image = FrameAtIndex(CurrentFrame());
   return image && image->isLazyGenerated();
 }
 
 ImageOrientation BitmapImage::CurrentFrameOrientation() {
   return FrameOrientationAtIndex(CurrentFrame());
 }
@@ skipping 37 matching lines @@
   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))
+  if (!all_data_received_ && !FrameIsReceivedAtIndex(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 ||
        animation_policy_ == kImageAnimationPolicyAnimateOnce) &&
       current_frame_ >= (FrameCount() - 1))
@@ skipping 32 matching lines @@
     frame_timer_ = WTF::WrapUnique(new TaskRunnerTimer<BitmapImage>(
         task_runner_, this, &BitmapImage::AdvanceAnimation));
     frame_timer_->StartOneShot(std::max(desired_frame_start_time_ - time, 0.),
                                BLINK_FROM_HERE);
   } else {
     // We've already reached or passed the time for the next frame to start.
     // See if we've also passed the time for frames after that to start, in
     // case we need to skip some frames entirely.  Remember not to advance
     // to an incomplete frame.
     for (size_t frame_after_next = (next_frame + 1) % FrameCount();
-         FrameIsCompleteAtIndex(frame_after_next);
+         FrameIsReceivedAtIndex(frame_after_next);
          frame_after_next = (next_frame + 1) % FrameCount()) {
       // Should we skip the next frame?
       double frame_after_next_start_time =
           desired_frame_start_time_ + FrameDurationAtIndex(next_frame);
       if (time < frame_after_next_start_time)
         break;
 
       // Skip the next frame by advancing the animation forward one frame.
       if (!InternalAdvanceAnimation(kSkipFramesToCatchUp)) {
         DCHECK(animation_finished_);
@@ skipping 112 matching lines @@
 
   return true;
 }
 
 void BitmapImage::NotifyObserversOfAnimationAdvance(TimerBase*) {
   if (GetImageObserver())
     GetImageObserver()->AnimationAdvanced(this);
 }
 
 }  // namespace blink