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.
+    static bool hasSufficientDataToSniffImageType(const SharedBuffer&);
+
     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