FrameIsCompleteAtIndex to FrameIsReceivedAtIndex

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

 /*
  * Copyright (C) 2012 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:
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 28 matching lines @@
 namespace blink {
 
 struct DeferredFrameData {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
   WTF_MAKE_NONCOPYABLE(DeferredFrameData);
 
  public:
   DeferredFrameData()
       : orientation_(kDefaultImageOrientation),
         duration_(0),
-        is_complete_(false),
+        is_received_(false),
         frame_bytes_(0),
         unique_id_(DecodingImageGenerator::kNeedNewImageUniqueID) {}
 
   ImageOrientation orientation_;
   float duration_;
-  bool is_complete_;
+  bool is_received_;
   size_t frame_bytes_;
   uint32_t unique_id_;
 };
 
 std::unique_ptr<DeferredImageDecoder> DeferredImageDecoder::Create(
     RefPtr<SharedBuffer> data,
     bool data_complete,
     ImageDecoder::AlphaOption alpha_option,
     const ColorBehavior& color_behavior) {
   std::unique_ptr<ImageDecoder> actual_decoder =
@@ skipping 146 matching lines @@
 }
 
 bool DeferredImageDecoder::FrameHasAlphaAtIndex(size_t index) const {
   if (actual_decoder_)
     return actual_decoder_->FrameHasAlphaAtIndex(index);
   if (!frame_generator_->IsMultiFrame())
     return frame_generator_->HasAlpha(index);
   return true;
 }
 
-bool DeferredImageDecoder::FrameIsCompleteAtIndex(size_t index) const {
+bool DeferredImageDecoder::FrameIsReceivedAtIndex(size_t index) const {
   if (actual_decoder_)
-    return actual_decoder_->FrameIsCompleteAtIndex(index);
+    return actual_decoder_->FrameIsReceivedAtIndex(index);
   if (index < frame_data_.size())
-    return frame_data_[index].is_complete_;
+    return frame_data_[index].is_received_;
   return false;
 }
 
 float DeferredImageDecoder::FrameDurationAtIndex(size_t index) const {
   if (actual_decoder_)
     return actual_decoder_->FrameDurationAtIndex(index);
   if (index < frame_data_.size())
     return frame_data_[index].duration_;
   return 0;
 }
@@ skipping 47 matching lines @@
   const size_t previous_size = frame_data_.size();
   frame_data_.resize(actual_decoder_->FrameCount());
 
   // We have encountered a broken image file. Simply bail.
   if (frame_data_.size() < previous_size)
     return;
 
   for (size_t i = previous_size; i < frame_data_.size(); ++i) {
     frame_data_[i].duration_ = actual_decoder_->FrameDurationAtIndex(i);
     frame_data_[i].orientation_ = actual_decoder_->Orientation();
-    frame_data_[i].is_complete_ = actual_decoder_->FrameIsCompleteAtIndex(i);
+    frame_data_[i].is_received_ = actual_decoder_->FrameIsReceivedAtIndex(i);
   }
 
   // The last lazy decoded frame created from previous call might be
   // incomplete so update its state.
   if (previous_size) {
     const size_t last_frame = previous_size - 1;
-    frame_data_[last_frame].is_complete_ =
-        actual_decoder_->FrameIsCompleteAtIndex(last_frame);
+    frame_data_[last_frame].is_received_ =
+        actual_decoder_->FrameIsReceivedAtIndex(last_frame);
   }
 
   if (all_data_received_) {
     repetition_count_ = actual_decoder_->RepetitionCount();
     actual_decoder_.reset();
     // Hold on to m_rwBuffer, which is still needed by createFrameAtIndex.
   }
 }
 
 sk_sp<SkImage> DeferredImageDecoder::CreateFrameImageAtIndex(
@@ skipping 16 matching lines @@
       frame_generator_, info, std::move(segment_reader), all_data_received_,
       index, frame_data_[index].unique_id_);
   generator->SetCanYUVDecode(can_yuv_decode_);
   sk_sp<SkImage> image = SkImage::MakeFromGenerator(std::move(generator));
   if (!image)
     return nullptr;
 
   // We can consider decoded bitmap constant and reuse uniqueID only after all
   // data is received.  We reuse it also for multiframe images when image data
   // is partially received but the frame data is fully received.
-  if (all_data_received_ || frame_data_[index].is_complete_) {
+  if (all_data_received_ || frame_data_[index].is_received_) {
     DCHECK(frame_data_[index].unique_id_ ==
                DecodingImageGenerator::kNeedNewImageUniqueID ||
            frame_data_[index].unique_id_ == image->uniqueID());
     frame_data_[index].unique_id_ = image->uniqueID();
   }
 
   return image;
 }
 
 bool DeferredImageDecoder::HotSpot(IntPoint& hot_spot) const {
   if (actual_decoder_)
     return actual_decoder_->HotSpot(hot_spot);
   if (has_hot_spot_)
     hot_spot = hot_spot_;
   return has_hot_spot_;
 }
 
 }  // namespace blink
 
 namespace WTF {
 template <>
 struct VectorTraits<blink::DeferredFrameData>
     : public SimpleClassVectorTraits<blink::DeferredFrameData> {
   STATIC_ONLY(VectorTraits);
   static const bool kCanInitializeWithMemset =
       false;  // Not all DeferredFrameData members initialize to 0.
 };
 }