Create ImageDecoder target color space

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 103 matching lines @@
           new ICOImageDecoder(alphaOption, colorOptions, maxDecodedBytes));
       break;
     case SniffResult::BMP:
       decoder.reset(
           new BMPImageDecoder(alphaOption, colorOptions, 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 231 matching lines @@
 
 namespace {
 
 // The output device color space is global and shared across multiple threads.
 SpinLock gTargetColorSpaceLock;
 SkColorSpace* gTargetColorSpace = nullptr;
 
 }  // namespace
 
 // static
-void ImageDecoder::setTargetColorProfile(const WebVector<char>& profile) {
+void ImageDecoder::setGlobalTargetColorProfile(const WebVector<char>& profile) {
   if (profile.isEmpty())
     return;
 
   // Take a lock around initializing and accessing the global device color
   // profile.
   SpinLock::Guard guard(gTargetColorSpaceLock);
 
   // Layout tests expect that only the first call will take effect.
   if (gTargetColorSpace)
     return;
 
   gTargetColorSpace =
       SkColorSpace::MakeICC(profile.data(), profile.size()).release();
 
   // UMA statistics.
   BitmapImageMetrics::countOutputGamma(gTargetColorSpace);
 }
 
+// static
+sk_sp<SkColorSpace> ImageDecoder::globalTargetColorSpace() {
+  // Take a lock around initializing and accessing the global device color
+  // profile.
+  SpinLock::Guard guard(gTargetColorSpaceLock);
+
+  // Initialize the output device profile to sRGB if it has not yet been
+  // 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())
     return nullptr;
 
   if (m_embeddedColorSpace)
     return m_embeddedColorSpace;
   return SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
 }
 
-void ImageDecoder::setColorProfileAndComputeTransform(const char* iccData,
-                                                      unsigned iccLength) {
+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";
-  setColorSpaceAndComputeTransform(std::move(colorSpace));
+  setEmbeddedColorSpace(std::move(colorSpace));
 }
 
-void ImageDecoder::setColorSpaceAndComputeTransform(
-    sk_sp<SkColorSpace> colorSpace) {
+void ImageDecoder::setEmbeddedColorSpace(sk_sp<SkColorSpace> colorSpace) {
   DCHECK(!m_ignoreColorSpace);
   DCHECK(!m_hasHistogrammedColorSpace);
 
   m_embeddedColorSpace = colorSpace;
+  m_sourceToTargetColorTransformNeedsUpdate = true;
+}
 
-  m_sourceToOutputDeviceColorTransform = nullptr;
+SkColorSpaceXform* ImageDecoder::colorTransform() {
+  if (!m_sourceToTargetColorTransformNeedsUpdate)
+    return m_sourceToTargetColorTransform.get();
+  m_sourceToTargetColorTransformNeedsUpdate = false;
+  m_sourceToTargetColorTransform = nullptr;
 
   // With color correct rendering, we do not transform to the output color space
   // at decode time.  Instead, we tag the raw image pixels and pass the tagged
   // SkImage to Skia.
   if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
-    return;
+    return nullptr;
 
   if (!m_embeddedColorSpace)
-    return;
+    return nullptr;
 
-  // Take a lock around initializing and accessing the global device color
-  // profile.
-  SpinLock::Guard guard(gTargetColorSpaceLock);
-
-  // Initialize the output device profile to sRGB if it has not yet been
-  // initialized.
-  if (!gTargetColorSpace) {
-    gTargetColorSpace =
-        SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named).release();
+  if (SkColorSpace::Equals(m_embeddedColorSpace.get(),
+                           m_targetColorSpace.get())) {
+    return nullptr;
   }
 
-  if (SkColorSpace::Equals(m_embeddedColorSpace.get(), gTargetColorSpace)) {
-    return;
-  }
-
-  m_sourceToOutputDeviceColorTransform =
-      SkColorSpaceXform::New(m_embeddedColorSpace.get(), gTargetColorSpace);
+  m_sourceToTargetColorTransform = SkColorSpaceXform::New(
+      m_embeddedColorSpace.get(), m_targetColorSpace.get());
+  return m_sourceToTargetColorTransform.get();
 }
 
 }  // namespace blink