Fix ImageDecoder::frameIsCompleteAtIndex - fully received instead of decoded.

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 25 matching lines @@
 
 namespace blink {
 
 struct DeferredFrameData {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
     WTF_MAKE_NONCOPYABLE(DeferredFrameData);
 public:
     DeferredFrameData()
         : m_orientation(DefaultImageOrientation)
         , m_duration(0)
-        , m_isComplete(false)
+        , m_isFullyReceived(false)
         , m_frameBytes(0)
         , m_uniqueID(DecodingImageGenerator::kNeedNewImageUniqueID)
     {}
 
     ImageOrientation m_orientation;
     float m_duration;
-    bool m_isComplete;
+    bool m_isFullyReceived;
     size_t m_frameBytes;
     uint32_t m_uniqueID;
 };
 
 PassOwnPtr<DeferredImageDecoder> DeferredImageDecoder::create(const SharedBuffer& data, ImageDecoder::AlphaOption alphaOption, ImageDecoder::GammaAndColorProfileOption colorOptions)
 {
     OwnPtr<ImageDecoder> actualDecoder = ImageDecoder::create(data, alphaOption, colorOptions);
 
     if (!actualDecoder)
         return nullptr;
@@ skipping 122 matching lines @@
 
 bool DeferredImageDecoder::frameHasAlphaAtIndex(size_t index) const
 {
     if (m_actualDecoder)
         return m_actualDecoder->frameHasAlphaAtIndex(index);
     if (!m_frameGenerator->isMultiFrame())
         return m_frameGenerator->hasAlpha(index);
     return true;
 }
 
-bool DeferredImageDecoder::frameIsCompleteAtIndex(size_t index) const
+bool DeferredImageDecoder::frameIsFullyReceivedAtIndex(size_t index) const
 {
     if (m_actualDecoder)
-        return m_actualDecoder->frameIsCompleteAtIndex(index);
+        return m_actualDecoder->frameIsFullyReceivedAtIndex(index);
     if (index < m_frameData.size())
-        return m_frameData[index].m_isComplete;
+        return m_frameData[index].m_isFullyReceived;
     return false;
 }
 
 float DeferredImageDecoder::frameDurationAtIndex(size_t index) const
 {
     if (m_actualDecoder)
         return m_actualDecoder->frameDurationAtIndex(index);
     if (index < m_frameData.size())
         return m_frameData[index].m_duration;
     return 0;
@@ skipping 45 matching lines @@
     const size_t previousSize = m_frameData.size();
     m_frameData.resize(m_actualDecoder->frameCount());
 
     // We have encountered a broken image file. Simply bail.
     if (m_frameData.size() < previousSize)
         return;
 
     for (size_t i = previousSize; i < m_frameData.size(); ++i) {
         m_frameData[i].m_duration = m_actualDecoder->frameDurationAtIndex(i);
         m_frameData[i].m_orientation = m_actualDecoder->orientation();
-        m_frameData[i].m_isComplete = m_actualDecoder->frameIsCompleteAtIndex(i);
+        m_frameData[i].m_isFullyReceived = m_actualDecoder->frameIsFullyReceivedAtIndex(i);
     }
 
     // The last lazy decoded frame created from previous call might be
     // incomplete so update its state.
     if (previousSize) {
         const size_t lastFrame = previousSize - 1;
-        m_frameData[lastFrame].m_isComplete = m_actualDecoder->frameIsCompleteAtIndex(lastFrame);
+        m_frameData[lastFrame].m_isFullyReceived = m_actualDecoder->frameIsFullyReceivedAtIndex(lastFrame);
     }
 
     if (m_allDataReceived) {
         m_repetitionCount = m_actualDecoder->repetitionCount();
         m_actualDecoder.reset();
         // Hold on to m_rwBuffer, which is still needed by createFrameAtIndex.
     }
 }
 
 inline SkImageInfo imageInfoFrom(const SkISize& decodedSize, bool knownToBeOpaque)
@@ skipping 10 matching lines @@
     RefPtr<SkROBuffer> roBuffer = adoptRef(m_rwBuffer->newRBufferSnapshot());
     RefPtr<SegmentReader> segmentReader = SegmentReader::createFromSkROBuffer(roBuffer.release());
     DecodingImageGenerator* generator = new DecodingImageGenerator(m_frameGenerator, imageInfoFrom(decodedSize, knownToBeOpaque), segmentReader.release(), m_allDataReceived, index, m_frameData[index].m_uniqueID);
     RefPtr<SkImage> image = adoptRef(SkImage::NewFromGenerator(generator)); // SkImage takes ownership of the 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 (m_allDataReceived || m_frameData[index].m_isComplete) {
+    if (m_allDataReceived || m_frameData[index].m_isFullyReceived) {
         DCHECK(m_frameData[index].m_uniqueID == DecodingImageGenerator::kNeedNewImageUniqueID || m_frameData[index].m_uniqueID == image->uniqueID());
         m_frameData[index].m_uniqueID = image->uniqueID();
     }
 
     generator->setCanYUVDecode(m_canYUVDecode);
 
     return image.release();
 }
 
 bool DeferredImageDecoder::hotSpot(IntPoint& hotSpot) const
 {
     // TODO: Implement.
     return m_actualDecoder ? m_actualDecoder->hotSpot(hotSpot) : false;
 }
 
 } // namespace blink
 
 namespace WTF {
 template<> struct VectorTraits<blink::DeferredFrameData> : public SimpleClassVectorTraits<blink::DeferredFrameData> {
     STATIC_ONLY(VectorTraits);
     static const bool canInitializeWithMemset = false; // Not all DeferredFrameData members initialize to 0.
 };
 }