Color: Read embedded ICC profiles regardless of QCMS

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 73 matching lines @@
 public:
     static const size_t noDecodedImageByteLimit = Platform::noDecodedImageByteLimit;
 
     enum AlphaOption {
         AlphaPremultiplied,
         AlphaNotPremultiplied
     };
 
     enum GammaAndColorProfileOption {
         GammaAndColorProfileApplied,
-        GammaAndColorProfileIgnored
+        GammaAndColorProfileNotApplied

[Justin Novosad, 2016/08/02 22:49:13]

You still need to keep the "Ignore" option IMHO.  Webgl and ImageBitmap have
special use cases that require this this semantic. 
NotApplied means that the color profile should be applied downstream.
Ignore means no color transformation should ever be applied, so do not attach
color profile data to the decoded image.

The ignore setting is used for stuff like loading webgl textures that have
non-color data (like bump maps, for example) 

     };
 
     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)
-        , m_sizeAvailable(false)
-        , m_isAllDataReceived(false)
-        , m_failed(false) { }
+        , m_bakeColorTransformToPixels(colorOptions == GammaAndColorProfileApplied) { }
 
     virtual ~ImageDecoder() { }
 
     // Returns a caller-owned decoder of the appropriate type.  Returns 0 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);
 
     virtual String filenameExtension() const = 0;
@@ skipping 95 matching lines @@
     // animated images.
     virtual float frameDurationAtIndex(size_t) const { return 0; }
 
     // Number of bytes in the decoded frame. Returns 0 if the decoder doesn't
     // have this frame cached (either because it hasn't been decoded, or because
     // it has been cleared).
     virtual size_t frameBytesAtIndex(size_t) const;
 
     ImageOrientation orientation() const { return m_orientation; }
 
-    void setIgnoreGammaAndColorProfile(bool flag) { m_ignoreGammaAndColorProfile = flag; }
-    bool ignoresGammaAndColorProfile() const { return m_ignoreGammaAndColorProfile; }
+    static void setTargetColorProfile(const WebVector<char>&);
 
-    static void setTargetColorProfile(const WebVector<char>&);
-    bool hasColorProfile() const;
+    // Note that hasColorProfile refers to the existence of an embedded color
+    // profile, and is independent of whether or not that profile's transform
+    // has been baked into the pixel values.
+    bool hasColorProfile() const { return m_hasColorProfile; }
+    void setColorProfileAndComputeTransform(const char* iccData, unsigned iccLength, bool hasAlpha, bool useSRGB);
 
 #if USE(QCMSLIB)
-    void setColorProfileAndTransform(const char* iccData, unsigned iccLength, bool hasAlpha, bool useSRGB);
+    // In contrast with hasColorProfile, this refers to the transform that has
+    // been baked into the pixels.
     qcms_transform* colorTransform() { return m_sourceToOutputDeviceColorTransform.get(); }
 #endif
 
     // Sets the "decode failure" flag.  For caller convenience (since so
     // many callers want to return false after calling this), returns false
     // to enable easy tailcalling.  Subclasses may override this to also
     // clean up any local data.
     virtual bool setFailed()
     {
         m_failed = true;
@@ skipping 56 matching lines @@
     // returns that number.
     virtual size_t decodeFrameCount() { return 1; }
 
     // Performs any additional setup of the requested frame after it has been
     // initially created, e.g. setting a duration or disposal method.
     virtual void initializeNewFrame(size_t) { }
 
     // Decodes the requested frame.
     virtual void decode(size_t) = 0;
 
+    // Returns the embedded image color profile.
+    const ImageFrame::ICCProfile& colorProfile() const { return m_colorProfile; }
+
     RefPtr<SegmentReader> m_data; // The encoded data.
     Vector<ImageFrame, 1> m_frameBufferCache;
     bool m_premultiplyAlpha;
-    bool m_ignoreGammaAndColorProfile;
     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.
     size_t m_maxDecodedBytes;
 
 private:
     // 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;
-    bool m_isAllDataReceived;
-    bool m_failed;
+    bool m_sizeAvailable = false;
+    bool m_isAllDataReceived = false;
+    bool m_failed = false;
+
+    const bool m_bakeColorTransformToPixels = false;
+
+    bool m_hasColorProfile = false;
+    ImageFrame::ICCProfile m_colorProfile;
 
 #if USE(QCMSLIB)
     QCMSTransformUniquePtr m_sourceToOutputDeviceColorTransform;
 #endif
 };
 
 } // namespace blink
 
 #endif