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

third_party/WebKit/Source/platform/image-decoders/ImageDecoderTestHelpers.cpp

 // Copyright 2015 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/ImageDecoderTestHelpers.h"
 
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/image-decoders/ImageFrame.h"
 #include "platform/testing/UnitTestHelpers.h"
@@ skipping 68 matching lines @@
         sourceData[1]->append(source++, 1u);
         // Alternate the buffers to cover the JPEGImageDecoder::onSetData restart code.
         decoder->setData(sourceData[length & 1].get(), length == data->size());
 
         EXPECT_LE(frameCount, decoder->frameCount());
         frameCount = decoder->frameCount();
 
         if (!decoder->isSizeAvailable())
             continue;
 
-        ImageFrame* frame = decoder->frameBufferAtIndex(frameCount - 1);
-        if (frame && frame->getStatus() == ImageFrame::FrameComplete && framesDecoded < frameCount)
+        bool frameIsFullyReceived = decoder->frameIsFullyReceivedAtIndex(framesDecoded);

[aleksandar.stojiljkovic, 2016/06/06 14:26:39]

The change here is that we decode frames one after another, not only frameCount
-1 frame. 

Note the change in behavior for webP which is returning only partially received
frames.
Might make sense to decode both here.

For ICO frames there is a difference comparet to all other decoders that memory
layout is different from frame order. Memory layout could be like this e.g.
|<frame1><frame0>| and framecount will return 1 frame until receiving full file
(when framecount would return 2).
At the end of file we don't want to count full decode for only for frame1 but
first completely decode frame0 here and then frame1 in loop bellow.  

+        for (size_t i = 0; i < framesDecoded; ++i) {
+            ASSERT_TRUE(decoder->frameIsFullyReceivedAtIndex(i));
+        }
+
+        ImageFrame* frame = decoder->frameBufferAtIndex(framesDecoded);
+
+        if (frameIsFullyReceived)
+            ASSERT_TRUE(decoder->frameIsCompleteAtIndex(framesDecoded) || decoder->failed());
+        if (!decoder->frameIsCompleteAtIndex(framesDecoded) && !decoder->failed())

[aleksandar.stojiljkovic, 2016/06/06 14:26:38]

Broken logic here - fullyReceived = trye for partially decoded frame would
trigger assert above. Removing this check and assert in next patch.

+            ASSERT_FALSE(decoder->frameIsFullyReceivedAtIndex(framesDecoded));
+
+        ASSERT_FALSE(decoder->frameIsCompleteAtIndex(frameCount));
+
+        if (frame && frame->getStatus() == ImageFrame::FrameComplete) {
+            ++framesDecoded;
+        }
+    }
+
+    for (size_t i = framesDecoded; i < frameCount; ++i) {
+        // ICO frames order doesn't match the order of frames as in memory
+        // and multiple frames can be completely decoded only when file is
+        // fully received.
+        // Attempt here to decode frames that were not decoded in the loop above,
+        // while the file content was partially available.
+        ASSERT_TRUE(decoder->frameIsFullyReceivedAtIndex(i));
+        ImageFrame* frame = decoder->frameBufferAtIndex(i);
+        if (frame && frame->getStatus() == ImageFrame::FrameComplete)

[aleksandar.stojiljkovic, 2016/06/06 14:26:38]

"&& framesDecoded < frameCount" was reequired for WebP as framecount is only
returning fullyreceived frames. New implementation tries to decode partially
received frames (outside of frameCount for webp)

             ++framesDecoded;
     }
 
+

[aleksandar.stojiljkovic, 2016/06/06 14:26:38]

Removed this newline.

     EXPECT_FALSE(decoder->failed());
     EXPECT_EQ(expectedFrameCount, decoder->frameCount());
     EXPECT_EQ(expectedFrameCount, framesDecoded);
     EXPECT_EQ(expectedRepetitionCount, decoder->repetitionCount());
 
     ASSERT_EQ(expectedFrameCount, baselineHashes.size());
     for (size_t i = 0; i < decoder->frameCount(); i++) {
         ImageFrame* frame = decoder->frameBufferAtIndex(i);
         EXPECT_EQ(baselineHashes[i], hashBitmap(frame->bitmap()));
     }
@@ skipping 28 matching lines @@
     // data in a segment, its pointer would no longer be valid.
     segmentedData->data();
 
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     ASSERT_FALSE(decoder->failed());
     EXPECT_EQ(frame->getStatus(), ImageFrame::FrameComplete);
     EXPECT_EQ(hashBitmap(frame->bitmap()), hash);
 }
 
 } // namespace blink