Explicitly specify target color space to ImageDecoder at creation

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

 /*
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 53 matching lines @@
 }
 
 // This needs to be updated if we ever add a matches*Signature() which requires
 // more characters.
 static constexpr size_t kLongestSignatureLength = sizeof("RIFF????WEBPVP") - 1;
 
 std::unique_ptr<ImageDecoder> ImageDecoder::create(
     PassRefPtr<SegmentReader> passData,
     bool dataComplete,
     AlphaOption alphaOption,
-    ColorSpaceOption colorOptions) {
+    ColorSpaceOption colorOptions,
+    sk_sp<SkColorSpace> targetColorSpace) {
   RefPtr<SegmentReader> data = passData;
 
+  // Ensure that the color space options are consistent.
+  if (colorOptions == ColorSpaceTransformed)
+    DCHECK(targetColorSpace);
+  else
+    DCHECK(!targetColorSpace);
+
   // We need at least kLongestSignatureLength bytes to run the signature
   // matcher.
   if (data->size() < kLongestSignatureLength)
     return nullptr;
 
   const size_t maxDecodedBytes =
       Platform::current() ? Platform::current()->maxDecodedImageBytes()
                           : noDecodedImageByteLimit;
 
   // Access the first kLongestSignatureLength chars to sniff the signature.
   // (note: FastSharedBufferReader only makes a copy if the bytes are segmented)
   char buffer[kLongestSignatureLength];
   const FastSharedBufferReader fastReader(data);
   const ImageDecoder::SniffResult sniffResult = determineImageType(
       fastReader.getConsecutiveData(0, kLongestSignatureLength, buffer),
       kLongestSignatureLength);
 
   std::unique_ptr<ImageDecoder> decoder;
   switch (sniffResult) {
     case SniffResult::JPEG:
-      decoder.reset(
-          new JPEGImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
+      decoder.reset(new JPEGImageDecoder(alphaOption, colorOptions,
+                                         std::move(targetColorSpace),
+                                         maxDecodedBytes));
       break;
     case SniffResult::PNG:
-      decoder.reset(
-          new PNGImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
+      decoder.reset(new PNGImageDecoder(alphaOption, colorOptions,
+                                        std::move(targetColorSpace),
+                                        maxDecodedBytes));
       break;
     case SniffResult::GIF:
-      decoder.reset(
-          new GIFImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
+      decoder.reset(new GIFImageDecoder(alphaOption, colorOptions,
+                                        std::move(targetColorSpace),
+                                        maxDecodedBytes));
       break;
     case SniffResult::WEBP:
-      decoder.reset(
-          new WEBPImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
+      decoder.reset(new WEBPImageDecoder(alphaOption, colorOptions,
+                                         std::move(targetColorSpace),
+                                         maxDecodedBytes));
       break;
     case SniffResult::ICO:
-      decoder.reset(
-          new ICOImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
+      decoder.reset(new ICOImageDecoder(alphaOption, colorOptions,
+                                        std::move(targetColorSpace),
+                                        maxDecodedBytes));
       break;
     case SniffResult::BMP:
-      decoder.reset(
-          new BMPImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
+      decoder.reset(new BMPImageDecoder(alphaOption, colorOptions,
+                                        std::move(targetColorSpace),
+                                        maxDecodedBytes));
       break;
     case SniffResult::Invalid:
       break;
   }
 
-  if (decoder) {
+  if (decoder)
     decoder->setData(data.release(), dataComplete);
-    decoder->m_targetColorSpace = globalTargetColorSpace();
-  }
 
   return decoder;
 }
 
 bool ImageDecoder::hasSufficientDataToSniffImageType(const SharedBuffer& data) {
   return data.size() >= kLongestSignatureLength;
 }
 
 ImageDecoder::SniffResult ImageDecoder::determineImageType(const char* contents,
                                                            size_t length) {
@@ skipping 128 matching lines @@
   ImageFrame* const buffer = &m_frameBufferCache[frameIndex];
 
   // If the frame is already initialized, return true.
   if (buffer->getStatus() != ImageFrame::FrameEmpty)
     return true;
 
   size_t requiredPreviousFrameIndex = buffer->requiredPreviousFrameIndex();
   if (requiredPreviousFrameIndex == kNotFound) {
     // This frame doesn't rely on any previous data.
     if (!buffer->setSizeAndColorSpace(size().width(), size().height(),
-                                      colorSpace())) {
+                                      colorSpaceForSkImages())) {
       return setFailed();
     }
   } else {
     ImageFrame* const prevBuffer =
         &m_frameBufferCache[requiredPreviousFrameIndex];
     DCHECK(prevBuffer->getStatus() == ImageFrame::FrameComplete);
 
     // We try to reuse |prevBuffer| as starting state to avoid copying.
     // If canReusePreviousFrameBuffer returns false, we must copy the data since
     // |prevBuffer| is necessary to decode this or later frames. In that case,
@@ skipping 165 matching lines @@
   // initialized.
   if (!gTargetColorSpace) {
     gTargetColorSpace =
         SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named).release();
   }
 
   gTargetColorSpace->ref();
   return sk_sp<SkColorSpace>(gTargetColorSpace);
 }
 
-sk_sp<SkColorSpace> ImageDecoder::colorSpace() const {
-  // TODO(ccameron): This should always return a non-null SkColorSpace. This is
-  // disabled for now because specifying a non-renderable color space results in
-  // errors.
-  // https://bugs.chromium.org/p/skia/issues/detail?id=5907
-  if (!RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
+sk_sp<SkColorSpace> ImageDecoder::colorSpaceForSkImages() const {
+  if (m_colorSpaceOption != ColorSpaceTagged)
     return nullptr;
 
   if (m_embeddedColorSpace)
     return m_embeddedColorSpace;
   return SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
 }
 
 void ImageDecoder::setEmbeddedColorProfile(const char* iccData,
                                            unsigned iccLength) {
   sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeICC(iccData, iccLength);
   if (!colorSpace)
     DLOG(ERROR) << "Failed to parse image ICC profile";
   setEmbeddedColorSpace(std::move(colorSpace));
 }
 
 void ImageDecoder::setEmbeddedColorSpace(sk_sp<SkColorSpace> colorSpace) {
-  DCHECK(!m_ignoreColorSpace);
+  DCHECK(!ignoresColorSpace());
   DCHECK(!m_hasHistogrammedColorSpace);
 
   m_embeddedColorSpace = colorSpace;
   m_sourceToTargetColorTransformNeedsUpdate = true;
 }
 
 SkColorSpaceXform* ImageDecoder::colorTransform() {
   if (!m_sourceToTargetColorTransformNeedsUpdate)
     return m_sourceToTargetColorTransform.get();
   m_sourceToTargetColorTransformNeedsUpdate = false;
@@ skipping 12 matching lines @@
                            m_targetColorSpace.get())) {
     return nullptr;
   }
 
   m_sourceToTargetColorTransform = SkColorSpaceXform::New(
       m_embeddedColorSpace.get(), m_targetColorSpace.get());
   return m_sourceToTargetColorTransform.get();
 }
 
 }  // namespace blink