Respect colorSpace in DecodingImageGenerator::onGetPixels()

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 99 matching lines @@
       m_decoderColorBehavior(colorBehavior),
       m_isMultiFrame(isMultiFrame),
       m_decodeFailed(false),
       m_yuvDecodingFailed(false),
       m_frameCount(0) {}
 
 ImageFrameGenerator::~ImageFrameGenerator() {
   ImageDecodingStore::instance().removeCacheIndexedByGenerator(this);
 }
 
-bool ImageFrameGenerator::decodeAndScale(SegmentReader* data,
-                                         bool allDataReceived,
-                                         size_t index,
-                                         const SkImageInfo& info,
-                                         void* pixels,
-                                         size_t rowBytes) {
+bool ImageFrameGenerator::decodeAndScale(
+    SegmentReader* data,
+    bool allDataReceived,
+    size_t index,
+    const SkImageInfo& info,
+    void* pixels,
+    size_t rowBytes,
+    ImageDecoder::AlphaOption alphaOption) {
   if (m_decodeFailed)
     return false;
 
   TRACE_EVENT1("blink", "ImageFrameGenerator::decodeAndScale", "frame index",
                static_cast<int>(index));
 
   // This implementation does not support scaling so check the requested size.
   SkISize scaledSize = SkISize::Make(info.width(), info.height());
   ASSERT(m_fullSize == scaledSize);
 
   // It is okay to allocate ref-counted ExternalMemoryAllocator on the stack,
   // because 1) it contains references to memory that will be invalid after
   // returning (i.e. a pointer to |pixels|) and therefore 2) should not live
   // longer than the call to the current method.
   ExternalMemoryAllocator externalAllocator(info, pixels, rowBytes);
   SkBitmap bitmap = tryToResumeDecode(data, allDataReceived, index, scaledSize,
-                                      &externalAllocator);
+                                      &externalAllocator, alphaOption);
   DCHECK(externalAllocator.unique());  // Verify we have the only ref-count.
 
   if (bitmap.isNull())
     return false;
 
   // Check to see if the decoder has written directly to the pixel memory
   // provided. If not, make a copy.
   ASSERT(bitmap.width() == scaledSize.width());
   ASSERT(bitmap.height() == scaledSize.height());
   SkAutoLockPixels bitmapLock(bitmap);
@@ skipping 41 matching lines @@
   ASSERT(decoder->failed());
   m_yuvDecodingFailed = true;
   return false;
 }
 
 SkBitmap ImageFrameGenerator::tryToResumeDecode(
     SegmentReader* data,
     bool allDataReceived,
     size_t index,
     const SkISize& scaledSize,
-    SkBitmap::Allocator* allocator) {
+    SkBitmap::Allocator* allocator,
+    ImageDecoder::AlphaOption alphaOption) {
   TRACE_EVENT1("blink", "ImageFrameGenerator::tryToResumeDecode", "frame index",
                static_cast<int>(index));
 
   ImageDecoder* decoder = 0;
 
   // Lock the mutex, so only one thread can use the decoder at once.
   MutexLocker lock(m_decodeMutex);
-  const bool resumeDecoding =
-      ImageDecodingStore::instance().lockDecoder(this, m_fullSize, &decoder);
+  const bool resumeDecoding = ImageDecodingStore::instance().lockDecoder(
+      this, m_fullSize, alphaOption, &decoder);
   ASSERT(!resumeDecoding || decoder);
 
   SkBitmap fullSizeImage;
-  bool complete =
-      decode(data, allDataReceived, index, &decoder, &fullSizeImage, allocator);
+  bool complete = decode(data, allDataReceived, index, &decoder, &fullSizeImage,
+                         allocator, alphaOption);
 
   if (!decoder)
     return SkBitmap();
 
   // If we are not resuming decoding that means the decoder is freshly
   // created and we have ownership. If we are resuming decoding then
   // the decoder is owned by ImageDecodingStore.
   std::unique_ptr<ImageDecoder> decoderContainer;
   if (!resumeDecoding)
     decoderContainer = WTF::wrapUnique(decoder);
@@ skipping 44 matching lines @@
       m_hasAlpha[i] = true;
   }
   m_hasAlpha[index] = hasAlpha;
 }
 
 bool ImageFrameGenerator::decode(SegmentReader* data,
                                  bool allDataReceived,
                                  size_t index,
                                  ImageDecoder** decoder,
                                  SkBitmap* bitmap,
-                                 SkBitmap::Allocator* allocator) {
+                                 SkBitmap::Allocator* allocator,
+                                 ImageDecoder::AlphaOption alphaOption) {
   ASSERT(m_decodeMutex.locked());
   TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width",
                m_fullSize.width(), "height", m_fullSize.height());
 
   // 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,
+      *decoder = ImageDecoder::create(data, allDataReceived, alphaOption,
                                       m_decoderColorBehavior)
                      .release();
       // The newly created decoder just grabbed the data.  No need to reset it.
       shouldCallSetData = false;
     }
 
     if (!*decoder)
       return false;
   }
 
-
   if (shouldCallSetData)
     (*decoder)->setData(data, allDataReceived);
 
   bool usingExternalAllocator = false;
 
   // For multi-frame image decoders, we need to know how many frames are
   // in that image in order to release the decoder when all frames are
   // decoded. frameCount() is reliable only if all data is received and set in
   // decoder, particularly with GIF.
   if (allDataReceived) {
@@ skipping 62 matching lines @@
   // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummyImagePlanes =
       WTF::wrapUnique(new ImagePlanes);
   decoder->setImagePlanes(std::move(dummyImagePlanes));
 
   return updateYUVComponentSizes(decoder.get(), sizeInfo->fSizes,
                                  sizeInfo->fWidthBytes);
 }
 
 }  // namespace blink