Merge color options into ColorBehavior

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 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ImageDecoder_h
 #define ImageDecoder_h
 
 #include "SkColorPriv.h"
 #include "SkColorSpaceXform.h"
 #include "platform/PlatformExport.h"
 #include "platform/SharedBuffer.h"
+#include "platform/graphics/ColorBehavior.h"
 #include "platform/graphics/ImageOrientation.h"
 #include "platform/image-decoders/ImageAnimation.h"
 #include "platform/image-decoders/ImageFrame.h"
 #include "platform/image-decoders/SegmentReader.h"
 #include "public/platform/Platform.h"
 #include "wtf/Assertions.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Threading.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
@@ skipping 35 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 ColorSpaceOption {
-    // The embedded color profile is ignored entirely. The hasEmbeddedColorSpace
-    // method will always return false. No transformations are applied to the
-    // pixel data. SkImages created will have no assocated SkColorSpace.
-    ColorSpaceIgnored,
-    // The image will be transformed to the specified target color space. The
-    // hasEmbeddedColorSpace method will return the truth. SkImages created by
-    // this decoder will have no associated SkColorSpace.
-    // TODO(ccameron): This transform is applied only if the image has an
-    // embedded color profile, but should be applied always.
-    ColorSpaceTransformed,
-    // The image will not be transformed (to the extent possible). SkImages
-    // created by this decoder will have the SkColorSpace of the embedded
-    // color profile (or sRGB if there was no embedded color profile).
-    ColorSpaceTagged,
-  };
-
   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,
-                                              ColorSpaceOption,
-                                              sk_sp<SkColorSpace>);
+                                              const ColorBehavior&);
   static std::unique_ptr<ImageDecoder> create(
       PassRefPtr<SharedBuffer> data,
       bool dataComplete,
       AlphaOption alphaoption,
-      ColorSpaceOption colorOptions,
-      sk_sp<SkColorSpace> targetColorSpace) {
+      const ColorBehavior& colorBehavior) {
     return create(SegmentReader::createFromSharedBuffer(std::move(data)),
-                  dataComplete, alphaoption, colorOptions, targetColorSpace);
+                  dataComplete, alphaoption, colorBehavior);
   }
 
   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&);
@@ skipping 82 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 ignoresColorSpace() const {
-    return m_colorSpaceOption == ColorSpaceIgnored;
-  }
-  ColorSpaceOption colorSpaceOption() const { return m_colorSpaceOption; }
-  sk_sp<SkColorSpace> targetColorSpace() const { return m_targetColorSpace; }
-
-  // Set the target color profile into which all images with embedded color
-  // profiles should be converted. Note that only the first call to this
-  // function in this process has any effect.
-  static void setGlobalTargetColorProfile(const WebVector<char>&);
-  static sk_sp<SkColorSpace> globalTargetColorSpace();
-
-  // A target color space to be used by tests.
-  static sk_sp<SkColorSpace> targetColorSpaceForTesting();
+  bool ignoresColorSpace() const { return m_colorBehavior.isIgnore(); }
+  const ColorBehavior& colorBehavior() const { return m_colorBehavior; }
 
   // This returns the color space that will be included in the SkImageInfo of
   // SkImages created from this decoder. This will be nullptr unless the
   // decoder was created with the option ColorSpaceTagged.
   sk_sp<SkColorSpace> colorSpaceForSkImages() const;
 
   // This returns whether or not the image included a not-ignored embedded
   // color space. This is independent of whether or not that space's transform
   // has been baked into the pixel values.
   bool hasEmbeddedColorSpace() const { return m_embeddedColorSpace.get(); }
@@ skipping 46 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,
-               ColorSpaceOption colorOptions,
-               sk_sp<SkColorSpace> targetColorSpace,
+               const ColorBehavior& colorBehavior,
                size_t maxDecodedBytes)
       : m_premultiplyAlpha(alphaOption == AlphaPremultiplied),
-        m_colorSpaceOption(colorOptions),
-        m_targetColorSpace(std::move(targetColorSpace)),
+        m_colorBehavior(colorBehavior),
         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 55 matching lines @@
   // the whole frame is opaque.
   //
   // This method should be called by the GIF and PNG decoder when the pixels in
   // the frame rect do *not* contain any transparent pixels. Before calling
   // this method, the caller must verify that the frame exists.
   void correctAlphaWhenFrameBufferSawNoAlpha(size_t);
 
   RefPtr<SegmentReader> m_data;  // The encoded data.
   Vector<ImageFrame, 1> m_frameBufferCache;
   const bool m_premultiplyAlpha;
-  const ColorSpaceOption m_colorSpaceOption;
-  const sk_sp<SkColorSpace> m_targetColorSpace;
+  const ColorBehavior m_colorBehavior;
   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 52 matching lines @@
   bool m_hasHistogrammedColorSpace = false;
 
   sk_sp<SkColorSpace> m_embeddedColorSpace = nullptr;
   bool m_sourceToTargetColorTransformNeedsUpdate = false;
   std::unique_ptr<SkColorSpaceXform> m_sourceToTargetColorTransform;
 };
 
 }  // namespace blink
 
 #endif