Refactor ImageDecoder factories

third_party/WebKit/Source/platform/image-decoders/ImageDecoder.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) Research In Motion Limited 2009-2010. 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
@@ skipping 76 matching lines @@
     enum AlphaOption {
         AlphaPremultiplied,
         AlphaNotPremultiplied
     };
 
     enum GammaAndColorProfileOption {
         GammaAndColorProfileApplied,
         GammaAndColorProfileIgnored
     };
 
-    enum class SniffResult {
-        JPEG,
-        PNG,
-        GIF,
-        WEBP,
-        ICO,
-        BMP,
-        InsufficientData,
-        Invalid
-    };
-
-    static SniffResult determineImageType(const char* data, size_t length);
-    static SniffResult determineImageType(const SharedBuffer&);
-    static SniffResult determineImageType(const SegmentReader&);
-
-    ImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes)
-        : m_premultiplyAlpha(alphaOption == AlphaPremultiplied)
-        , m_ignoreGammaAndColorProfile(colorOptions == GammaAndColorProfileIgnored)
-        , m_maxDecodedBytes(maxDecodedBytes) { }
-
     virtual ~ImageDecoder() { }
 
-    // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
+    // Returns a caller-owned decoder of the appropriate type.  Returns nullptr if
     // we can't sniff a supported type from the provided data (possibly
     // because there isn't enough data yet).
     // Sets m_maxDecodedBytes to Platform::maxImageDecodedBytes().
-    static std::unique_ptr<ImageDecoder> create(SniffResult, AlphaOption, GammaAndColorProfileOption);
+    static std::unique_ptr<ImageDecoder> create(PassRefPtr<SegmentReader> data, bool dataComplete,
+        AlphaOption, GammaAndColorProfileOption);
+    static std::unique_ptr<ImageDecoder> create(PassRefPtr<SharedBuffer> data, bool dataComplete,
+        AlphaOption alphaoption, GammaAndColorProfileOption colorOptions)
+    {
+        return create(SegmentReader::createFromSharedBuffer(data), dataComplete, alphaoption, colorOptions);
+    }
+
 
     virtual String filenameExtension() const = 0;
 
     bool isAllDataReceived() const { return m_isAllDataReceived; }
 
+    // Returns true if the buffer holds enough data to instantiate a decoder. This is useful for
+    // callers to determine whether a decoder instantiation failure is due to insufficient or bad data.

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

Nit: Seems like most of this file prefers to wrap comments at 80 cols.

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

Done.

+    static bool isSufficientData(const SharedBuffer&);

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

Nit: I'm not a big fan of this function name.  Something like
hasSufficientDataToSniffImageType() or canSniffImageType() might be better. 
(The latter reads more clearly but I'm worried it implies we should return false
if the sniffed type is invalid.)

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

Changed to hasSufficientDataToSniffImageType().

+
     void setData(PassRefPtr<SegmentReader> data, bool allDataReceived)
     {
         if (m_failed)
             return;
         m_data = data;
         m_isAllDataReceived = allDataReceived;
         onSetData(m_data.get());
     }
 
     void setData(PassRefPtr<SharedBuffer> data, bool allDataReceived)
@@ skipping 136 matching lines @@
                 findRequiredPreviousFrame(0, false));
         }
         m_frameBufferCache[0].setMemoryAllocator(allocator);
     }
 
     virtual bool canDecodeToYUV() { return false; }
     virtual bool decodeToYUV() { return false; }
     virtual void setImagePlanes(std::unique_ptr<ImagePlanes>) { }
 
 protected:
+    ImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes)
+        : m_premultiplyAlpha(alphaOption == AlphaPremultiplied)
+        , m_ignoreGammaAndColorProfile(colorOptions == GammaAndColorProfileIgnored)
+        , m_maxDecodedBytes(maxDecodedBytes) { }
+
     // Calculates the most recent frame whose image data may be needed in
     // order to decode frame |frameIndex|, based on frame disposal methods
     // and |frameRectIsOpaque|, where |frameRectIsOpaque| signifies whether
     // the rectangle of frame at |frameIndex| is known to be opaque.
     // If no previous frame's data is required, returns WTF::kNotFound.
     //
     // This function requires that the previous frame's
     // |m_requiredPreviousFrameIndex| member has been set correctly. The
     // easiest way to ensure this is for subclasses to call this method and
     // store the result on the frame via setRequiredPreviousFrameIndex()
@@ skipping 32 matching lines @@
     ImageOrientation m_orientation;
 
     // The maximum amount of memory a decoded image should require. Ideally,
     // image decoders should downsample large images to fit under this limit
     // (and then return the downsampled size from decodedSize()). Ignoring
     // this limit can cause excessive memory use or even crashes on low-
     // memory devices.
     const size_t m_maxDecodedBytes;
 
 private:
+    enum class SniffResult {
+        JPEG,
+        PNG,
+        GIF,
+        WEBP,
+        ICO,
+        BMP,
+        Invalid
+    };
+
+    static SniffResult determineImageType(const char* data, size_t length);
+
     // Some code paths compute the size of the image as "width * height * 4"
     // and return it as a (signed) int.  Avoid overflow.
     static bool sizeCalculationMayOverflow(unsigned width, unsigned height)
     {
         unsigned long long total_size = static_cast<unsigned long long>(width)
                                       * static_cast<unsigned long long>(height);
         return total_size > ((1 << 29) - 1);
     }
 
     IntSize m_size;
     bool m_sizeAvailable = false;
     bool m_isAllDataReceived = false;
     bool m_failed = false;
 
     bool m_hasColorProfile = false;
     ImageFrame::ICCProfile m_colorProfile;
 
 #if USE(QCMSLIB)
     QCMSTransformUniquePtr m_sourceToOutputDeviceColorTransform;
 #endif
 };
 
 } // namespace blink
 
 #endif