Refactor image decoders to use 'colorSpace' instead of 'colorProfile'

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 68 matching lines @@
 class PLATFORM_EXPORT ImageDecoder {
   WTF_MAKE_NONCOPYABLE(ImageDecoder);
   USING_FAST_MALLOC(ImageDecoder);
 
  public:
   static const size_t noDecodedImageByteLimit =
       Platform::noDecodedImageByteLimit;
 
   enum AlphaOption { AlphaPremultiplied, AlphaNotPremultiplied };
 
-  enum GammaAndColorProfileOption {
-    GammaAndColorProfileApplied,
-    GammaAndColorProfileIgnored
-  };
+  enum ColorSpaceOption { ColorSpaceApplied, ColorSpaceIgnored };
 
   virtual ~ImageDecoder() {}
 
   // 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(PassRefPtr<SegmentReader> data,
                                               bool dataComplete,
                                               AlphaOption,
-                                              GammaAndColorProfileOption);
-  static std::unique_ptr<ImageDecoder> create(
-      PassRefPtr<SharedBuffer> data,
-      bool dataComplete,
-      AlphaOption alphaoption,
-      GammaAndColorProfileOption colorOptions) {
+                                              ColorSpaceOption);
+  static std::unique_ptr<ImageDecoder> create(PassRefPtr<SharedBuffer> data,
+                                              bool dataComplete,
+                                              AlphaOption alphaoption,
+                                              ColorSpaceOption colorOptions) {
     return create(SegmentReader::createFromSharedBuffer(std::move(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
@@ skipping 84 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; }
 
-  bool ignoresGammaAndColorProfile() const {
-    return m_ignoreGammaAndColorProfile;
-  }
+  bool ignoresColorSpace() const { return m_ignoreColorSpace; }
   static void setTargetColorProfile(const WebVector<char>&);
 
-  // Note that hasColorProfile refers to the existence of a not-ignored
-  // 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; }
+  // Note that hasColorSpace refers to the existence of a not-ignored
+  // embedded color space, and is independent of whether or not that
+  // space's transform has been baked into the pixel values.
+  bool hasColorSpace() const { return m_srcSpace.get(); }
   void setColorSpaceAndComputeTransform(const char* iccData,
-                                        unsigned iccLength,
-                                        bool useSRGB);
+                                        unsigned iccLength);
+  void setColorSpaceAndComputeTransform(sk_sp<SkColorSpace> srcSpace);
 
   // Transformation from encoded color space to target color space.
   SkColorSpaceXform* colorTransform() {
     return m_sourceToOutputDeviceColorTransform.get();
   }
 
   // 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.
@@ skipping 23 matching lines @@
     }
     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,
+               ColorSpaceOption colorOptions,
                size_t maxDecodedBytes)
       : m_premultiplyAlpha(alphaOption == AlphaPremultiplied),
-        m_ignoreGammaAndColorProfile(colorOptions ==
-                                     GammaAndColorProfileIgnored),
+        m_ignoreColorSpace(colorOptions == ColorSpaceIgnored),
         m_maxDecodedBytes(maxDecodedBytes),
         m_purgeAggressively(false) {}
 
   // 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
@@ skipping 18 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; }
+  // Returns the embedded image color space.
+  sk_sp<SkColorSpace> colorSpace() const { return m_srcSpace; }
 
   RefPtr<SegmentReader> m_data;  // The encoded data.
   Vector<ImageFrame, 1> m_frameBufferCache;
   const bool m_premultiplyAlpha;
-  const bool m_ignoreGammaAndColorProfile;
+  const bool m_ignoreColorSpace;
   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;
 
   // While decoding, we may learn that there are so many animation frames that
@@ skipping 14 matching lines @@
     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;
-
+  sk_sp<SkColorSpace> m_srcSpace = nullptr;
   std::unique_ptr<SkColorSpaceXform> m_sourceToOutputDeviceColorTransform;
 };
 
 }  // namespace blink
 
 #endif