Add support for Animated PNG

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/ImageFrame.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 206 matching lines @@
                                         SharedBuffer* data,
                                         size_t frameOffset,
                                         bool hasColorSpace,
                                         int expectedRepetitionCount) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
   EXPECT_LT(frameOffset, data->size());
 
   // Send data to the decoder byte-by-byte and use the provided frame offset in
   // the data to check that isSizeAvailable() changes state only when that
   // offset is reached. Also check other decoder state.
+  RefPtr<SharedBuffer> tempData = SharedBuffer::create();
+  const char* source = data->data();
   for (size_t length = 1; length <= frameOffset; ++length) {
-    RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), length);
+    tempData->append(source++, 1u);
     decoder->setData(tempData.get(), false);
 
     if (length < frameOffset) {
       EXPECT_FALSE(decoder->isSizeAvailable());
       EXPECT_TRUE(decoder->size().isEmpty());
       EXPECT_FALSE(decoder->hasEmbeddedColorSpace());
       EXPECT_EQ(0u, decoder->frameCount());
       EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount());
       EXPECT_FALSE(decoder->frameBufferAtIndex(0));
     } else {
@@ skipping 12 matching lines @@
                                     SharedBuffer* fullData,
                                     size_t increment) {
   const size_t fullLength = fullData->size();
 
   std::unique_ptr<ImageDecoder> decoder;
 
   Vector<unsigned> truncatedHashes;
   Vector<unsigned> progressiveHashes;
 
   // Compute hashes when the file is truncated.
+  RefPtr<SharedBuffer> data = SharedBuffer::create();
+  const char* source = fullData->data();
   for (size_t i = 1; i <= fullLength; i += increment) {
     decoder = createDecoder();
-    RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i);
+    data->append(source++, 1u);
     decoder->setData(data.get(), i == fullLength);
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     if (!frame) {
       truncatedHashes.append(0);
       continue;
     }
     truncatedHashes.append(hashBitmap(frame->bitmap()));
   }
 
   // Compute hashes when the file is progressively decoded.
   decoder = createDecoder();
+  data = SharedBuffer::create();
+  source = fullData->data();
   for (size_t i = 1; i <= fullLength; i += increment) {
-    RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i);
+    data->append(source++, 1u);
     decoder->setData(data.get(), i == fullLength);
     ImageFrame* frame = decoder->frameBufferAtIndex(0);
     if (!frame) {
       progressiveHashes.append(0);
       continue;
     }
     progressiveHashes.append(hashBitmap(frame->bitmap()));
   }
 
   for (size_t i = 0; i < truncatedHashes.size(); ++i)
     ASSERT_EQ(truncatedHashes[i], progressiveHashes[i]);
 }
 
 void testUpdateRequiredPreviousFrameAfterFirstDecode(
     DecoderCreator createDecoder,
     SharedBuffer* fullData) {
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   // Give it data that is enough to parse but not decode in order to check the
   // status of requiredPreviousFrameIndex before decoding.
-  size_t partialSize = 1;
+  RefPtr<SharedBuffer> data = SharedBuffer::create();
+  const char* source = fullData->data();
   do {
-    RefPtr<SharedBuffer> data =
-        SharedBuffer::create(fullData->data(), partialSize);
+    data->append(source++, 1u);
     decoder->setData(data.get(), false);
-    ++partialSize;
   } while (!decoder->frameCount() ||
            decoder->frameBufferAtIndex(0)->getStatus() ==
                ImageFrame::FrameEmpty);
 
   EXPECT_EQ(kNotFound,
             decoder->frameBufferAtIndex(0)->requiredPreviousFrameIndex());
   unsigned frameCount = decoder->frameCount();
   for (size_t i = 1; i < frameCount; ++i) {
     EXPECT_EQ(i - 1,
               decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex());
   }
 
   decoder->setData(fullData, true);
   for (size_t i = 0; i < frameCount; ++i) {
     EXPECT_EQ(kNotFound,
               decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex());
   }
 }
 
 void testResumePartialDecodeAfterClearFrameBufferCache(
     DecoderCreator createDecoder,
     SharedBuffer* fullData) {
   Vector<unsigned> baselineHashes;
   createDecodingBaseline(createDecoder, fullData, &baselineHashes);
   size_t frameCount = baselineHashes.size();
 
   std::unique_ptr<ImageDecoder> decoder = createDecoder();
 
   // Let frame 0 be partially decoded.
-  size_t partialSize = 1;
+  RefPtr<SharedBuffer> data = SharedBuffer::create();
+  const char* source = fullData->data();
   do {
-    RefPtr<SharedBuffer> data =
-        SharedBuffer::create(fullData->data(), partialSize);
+    data->append(source++, 1u);
     decoder->setData(data.get(), false);
-    ++partialSize;
   } while (!decoder->frameCount() ||
            decoder->frameBufferAtIndex(0)->getStatus() ==
                ImageFrame::FrameEmpty);
 
   // Skip to the last frame and clear.
   decoder->setData(fullData, true);
   EXPECT_EQ(frameCount, decoder->frameCount());
   ImageFrame* lastFrame = decoder->frameBufferAtIndex(frameCount - 1);
   EXPECT_EQ(baselineHashes[frameCount - 1], hashBitmap(lastFrame->bitmap()));
   decoder->clearCacheExceptFrame(kNotFound);
@@ skipping 221 matching lines @@
   size_t frameCount = decoderA->frameCount();
   ASSERT_EQ(frameCount, decoderB->frameCount());
 
   for (size_t i = 0; i < frameCount; ++i) {
     verifyFramesMatch(file, decoderA->frameBufferAtIndex(i),
                       decoderB->frameBufferAtIndex(i));
   }
 }
 
 }  // namespace blink