Refactor ImageDecoder factories

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

 // Copyright 2016 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/graphics/DeferredImageDecoder.h"
 
 #include "platform/SharedBuffer.h"
 #include "platform/image-decoders/ImageDecoderTestHelpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkImage.h"
@@ skipping 17 matching lines @@
  *
  *  @param fileName File to decode
  *  @param bytesForFirstFrame Number of bytes needed to return an SkImage
  *  @param laterFrame Frame to decode with almost complete data. Can be 0.
  */
 static void mixImages(const char* fileName, size_t bytesForFirstFrame, size_t laterFrame)
 {
     RefPtr<SharedBuffer> file = readFile(fileName);
     ASSERT_NE(file, nullptr);
 
-    std::unique_ptr<DeferredImageDecoder> decoder = DeferredImageDecoder::create(ImageDecoder::determineImageType(*file.get()), ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileIgnored);
-    ASSERT_TRUE(decoder.get());
-
     RefPtr<SharedBuffer> partialFile = SharedBuffer::create(file->data(), bytesForFirstFrame);
-    decoder->setData(*partialFile.get(), false);
+    std::unique_ptr<DeferredImageDecoder> decoder = DeferredImageDecoder::create(partialFile, false,
+        ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileIgnored);
+    ASSERT_NE(decoder, nullptr);
     RefPtr<SkImage> partialImage = decoder->createFrameAtIndex(0);
 
     RefPtr<SharedBuffer> almostCompleteFile = SharedBuffer::create(file->data(), file->size() - 1);
-    decoder->setData(*almostCompleteFile.get(), false);
+    decoder->setData(almostCompleteFile, false);
     RefPtr<SkImage> imageWithMoreData = decoder->createFrameAtIndex(laterFrame);
 
     imageWithMoreData->preroll();
     partialImage->preroll();
 }
 
 TEST(DeferredImageDecoderTestWoPlatform, mixImagesGif)
 {
     mixImages("/LayoutTests/fast/images/resources/animated.gif", 818u, 1u);
 }
@@ skipping 20 matching lines @@
 
 TEST(DeferredImageDecoderTestWoPlatform, mixImagesIco)
 {
     mixImages("/LayoutTests/fast/images/resources/wrong-frame-dimensions.ico", 1376u, 1u);
 }
 
 TEST(DeferredImageDecoderTestWoPlatform, fragmentedSignature)
 {
     struct {
         const char* m_file;
-        ImageDecoder::SniffResult m_expectedResult;

[Peter Kasting, 2016/08/19 23:04:58]

It seems like we've lost the functionality of checking that the correct type is
sniffed.  Is that tested elsewhere?  If so, remove the struct wrapper around the
single remaining member.  If not, check the image type of the resulting image
decoder.

[f(malita), 2016/08/22 01:51:15]

Indeed.  I would hope we have other tests to verify correct decoder selection,
but it's also trivial to update this one and check as you suggested.  Done.

     } tests[] = {
-        { "/LayoutTests/fast/images/resources/animated.gif", ImageDecoder::SniffResult::GIF },
-        { "/LayoutTests/fast/images/resources/mu.png", ImageDecoder::SniffResult::PNG },
-        { "/LayoutTests/fast/images/resources/2-dht.jpg", ImageDecoder::SniffResult::JPEG },
-        { "/LayoutTests/fast/images/resources/webp-animated.webp", ImageDecoder::SniffResult::WEBP },
-        { "/LayoutTests/fast/images/resources/lenna.bmp", ImageDecoder::SniffResult::BMP },
-        { "/LayoutTests/fast/images/resources/wrong-frame-dimensions.ico", ImageDecoder::SniffResult::ICO },
+        { "/LayoutTests/fast/images/resources/animated.gif" },
+        { "/LayoutTests/fast/images/resources/mu.png" },
+        { "/LayoutTests/fast/images/resources/2-dht.jpg" },
+        { "/LayoutTests/fast/images/resources/webp-animated.webp" },
+        { "/LayoutTests/fast/images/resources/lenna.bmp" },
+        { "/LayoutTests/fast/images/resources/wrong-frame-dimensions.ico" },
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(tests); ++i) {
         RefPtr<SharedBuffer> fileBuffer = readFile(tests[i].m_file);
         ASSERT_NE(fileBuffer, nullptr);
         // We need contiguous data, which SharedBuffer doesn't guarantee.
         sk_sp<SkData> skData = fileBuffer->getAsSkData();
         ASSERT_EQ(skData->size(), fileBuffer->size());
         const char* data = reinterpret_cast<const char*>(skData->bytes());
 
-        // Truncated signature (only 1 byte)
+        // Truncated signature (only 1 byte).  Decoder instantiation should fail.
         RefPtr<SharedBuffer> buffer = SharedBuffer::create<size_t>(data, 1u);
-        ASSERT_EQ(ImageDecoder::determineImageType(*buffer), ImageDecoder::SniffResult::InsufficientData);
+        ASSERT_FALSE(ImageDecoder::isSufficientData(*buffer));
+        ASSERT_EQ(nullptr, DeferredImageDecoder::create(buffer, false,
+            ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileIgnored));
 
         // Append the rest of the data.  We should be able to sniff the signature now, even if segmented.
         buffer->append<size_t>(data + 1, skData->size() - 1);
-        ASSERT_EQ(ImageDecoder::determineImageType(*buffer), tests[i].m_expectedResult);
+        ASSERT_TRUE(ImageDecoder::isSufficientData(*buffer));
+        ASSERT_NE(nullptr, DeferredImageDecoder::create(buffer, false,
+            ImageDecoder::AlphaPremultiplied, ImageDecoder::GammaAndColorProfileIgnored));
     }
 }
 
 } // namespace blink