Explicitly specify target color space to ImageDecoder at creation

third_party/WebKit/Source/platform/graphics/ImageFrameGenerator.cpp

 /*
  * Copyright (C) 2012 Google Inc. 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 85 matching lines @@
   componentWidthBytes[0] = decoder->decodedYUVWidthBytes(0);
   size = decoder->decodedYUVSize(1);
   componentSizes[1].set(size.width(), size.height());
   componentWidthBytes[1] = decoder->decodedYUVWidthBytes(1);
   size = decoder->decodedYUVSize(2);
   componentSizes[2].set(size.width(), size.height());
   componentWidthBytes[2] = decoder->decodedYUVWidthBytes(2);
   return true;
 }
 
-ImageFrameGenerator::ImageFrameGenerator(const SkISize& fullSize,
-                                         sk_sp<SkColorSpace> colorSpace,
-                                         bool isMultiFrame)
+ImageFrameGenerator::ImageFrameGenerator(
+    const SkISize& fullSize,
+    bool isMultiFrame,
+    ImageDecoder::ColorSpaceOption decoderColorSpaceOption,
+    sk_sp<SkColorSpace> decoderTargetColorSpace)
     : m_fullSize(fullSize),
-      m_colorSpace(std::move(colorSpace)),
+      m_decoderColorSpaceOption(decoderColorSpaceOption),
+      m_decoderTargetColorSpace(std::move(decoderTargetColorSpace)),
       m_isMultiFrame(isMultiFrame),
       m_decodeFailed(false),
       m_yuvDecodingFailed(false),
       m_frameCount(0) {}
 
 ImageFrameGenerator::~ImageFrameGenerator() {
   ImageDecodingStore::instance().removeCacheIndexedByGenerator(this);
 }
 
 bool ImageFrameGenerator::decodeAndScale(SegmentReader* data,
@@ skipping 46 matching lines @@
     return false;
 
   TRACE_EVENT1("blink", "ImageFrameGenerator::decodeToYUV", "frame index",
                static_cast<int>(index));
 
   if (!planes || !planes[0] || !planes[1] || !planes[2] || !rowBytes ||
       !rowBytes[0] || !rowBytes[1] || !rowBytes[2]) {
     return false;
   }
 
-  std::unique_ptr<ImageDecoder> decoder =
-      ImageDecoder::create(data, true, ImageDecoder::AlphaPremultiplied,
-                           ImageDecoder::ColorSpaceApplied);
+  std::unique_ptr<ImageDecoder> decoder = ImageDecoder::create(
+      data, true, ImageDecoder::AlphaPremultiplied, m_decoderColorSpaceOption,
+      m_decoderTargetColorSpace);
   // getYUVComponentSizes was already called and was successful, so
   // ImageDecoder::create must succeed.
   ASSERT(decoder);
 
   std::unique_ptr<ImagePlanes> imagePlanes =
       makeUnique<ImagePlanes>(planes, rowBytes);
   decoder->setImagePlanes(std::move(imagePlanes));
 
   ASSERT(decoder->canDecodeToYUV());
 
@@ skipping 99 matching lines @@
   // Try to create an ImageDecoder if we are not given one.
   ASSERT(decoder);
   bool newDecoder = false;
   bool shouldCallSetData = true;
   if (!*decoder) {
     newDecoder = true;
     if (m_imageDecoderFactory)
       *decoder = m_imageDecoderFactory->create().release();
 
     if (!*decoder) {
-      *decoder = ImageDecoder::create(data, allDataReceived,
-                                      ImageDecoder::AlphaPremultiplied,
-                                      ImageDecoder::ColorSpaceApplied)
+      *decoder = ImageDecoder::create(
+                     data, allDataReceived, ImageDecoder::AlphaPremultiplied,
+                     m_decoderColorSpaceOption, m_decoderTargetColorSpace)
                      .release();
       // The newly created decoder just grabbed the data.  No need to reset it.
       shouldCallSetData = false;
     }
 
     if (!*decoder)
       return false;
   }
 
   if (!m_isMultiFrame && newDecoder && allDataReceived) {
@@ skipping 49 matching lines @@
 bool ImageFrameGenerator::getYUVComponentSizes(SegmentReader* data,
                                                SkYUVSizeInfo* sizeInfo) {
   TRACE_EVENT2("blink", "ImageFrameGenerator::getYUVComponentSizes", "width",
                m_fullSize.width(), "height", m_fullSize.height());
 
   if (m_yuvDecodingFailed)
     return false;
 
   std::unique_ptr<ImageDecoder> decoder =
       ImageDecoder::create(data, true, ImageDecoder::AlphaPremultiplied,
-                           ImageDecoder::ColorSpaceApplied);
+                           ImageDecoder::ColorSpaceTransformed,
+                           ImageDecoder::globalTargetColorSpace());
   if (!decoder)
     return false;
 
   // Setting a dummy ImagePlanes object signals to the decoder that we want to
   // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummyImagePlanes = wrapUnique(new ImagePlanes);
   decoder->setImagePlanes(std::move(dummyImagePlanes));
 
   return updateYUVComponentSizes(decoder.get(), sizeInfo->fSizes,
                                  sizeInfo->fWidthBytes);
 }
 
 }  // namespace blink