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 @@
       decoder_color_behavior_(color_behavior),
       is_multi_frame_(is_multi_frame),
       decode_failed_(false),
       yuv_decoding_failed_(false),
       frame_count_(0) {}
 
 ImageFrameGenerator::~ImageFrameGenerator() {
   ImageDecodingStore::Instance().RemoveCacheIndexedByGenerator(this);
 }
 
-bool ImageFrameGenerator::DecodeAndScale(SegmentReader* data,
-                                         bool all_data_received,
-                                         size_t index,
-                                         const SkImageInfo& info,
-                                         void* pixels,
-                                         size_t row_bytes) {
+bool ImageFrameGenerator::DecodeAndScale(
+    SegmentReader* data,
+    bool all_data_received,
+    size_t index,
+    const SkImageInfo& info,
+    void* pixels,
+    size_t row_bytes,
+    ImageDecoder::AlphaOption alpha_option) {
   if (decode_failed_)
     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 scaled_size = SkISize::Make(info.width(), info.height());
   ASSERT(full_size_ == scaled_size);
 
   // 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 external_allocator(info, pixels, row_bytes);
-  SkBitmap bitmap = TryToResumeDecode(data, all_data_received, index,
-                                      scaled_size, &external_allocator);
+  SkBitmap bitmap =
+      TryToResumeDecode(data, all_data_received, index, scaled_size,
+                        &external_allocator, alpha_option);
   DCHECK(external_allocator.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() == scaled_size.width());
   ASSERT(bitmap.height() == scaled_size.height());
   SkAutoLockPixels bitmap_lock(bitmap);
@@ skipping 41 matching lines @@
   ASSERT(decoder->Failed());
   yuv_decoding_failed_ = true;
   return false;
 }
 
 SkBitmap ImageFrameGenerator::TryToResumeDecode(
     SegmentReader* data,
     bool all_data_received,
     size_t index,
     const SkISize& scaled_size,
-    SkBitmap::Allocator* allocator) {
+    SkBitmap::Allocator* allocator,
+    ImageDecoder::AlphaOption alpha_option) {
   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(decode_mutex_);
-  const bool resume_decoding =
-      ImageDecodingStore::Instance().LockDecoder(this, full_size_, &decoder);
+  const bool resume_decoding = ImageDecodingStore::Instance().LockDecoder(
+      this, full_size_, alpha_option, &decoder);
   ASSERT(!resume_decoding || decoder);
 
   SkBitmap full_size_image;
   bool complete = Decode(data, all_data_received, index, &decoder,
-                         &full_size_image, allocator);
+                         &full_size_image, allocator, alpha_option);
 
   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> decoder_container;
   if (!resume_decoding)
     decoder_container = WTF::WrapUnique(decoder);
@@ skipping 44 matching lines @@
       has_alpha_[i] = true;
   }
   has_alpha_[index] = has_alpha;
 }
 
 bool ImageFrameGenerator::Decode(SegmentReader* data,
                                  bool all_data_received,
                                  size_t index,
                                  ImageDecoder** decoder,
                                  SkBitmap* bitmap,
-                                 SkBitmap::Allocator* allocator) {
+                                 SkBitmap::Allocator* allocator,
+                                 ImageDecoder::AlphaOption alpha_option) {
   ASSERT(decode_mutex_.Locked());
   TRACE_EVENT2("blink", "ImageFrameGenerator::decode", "width",
                full_size_.width(), "height", full_size_.height());
 
   // Try to create an ImageDecoder if we are not given one.
   ASSERT(decoder);
   bool new_decoder = false;
   bool should_call_set_data = true;
   if (!*decoder) {
     new_decoder = true;
     if (image_decoder_factory_)
       *decoder = image_decoder_factory_->Create().release();
 
     if (!*decoder) {
-      *decoder = ImageDecoder::Create(data, all_data_received,
-                                      ImageDecoder::kAlphaPremultiplied,
+      *decoder = ImageDecoder::Create(data, all_data_received, alpha_option,
                                       decoder_color_behavior_)
                      .release();
       // The newly created decoder just grabbed the data.  No need to reset it.
       should_call_set_data = false;
     }
 
     if (!*decoder)
       return false;
   }
 
@@ skipping 72 matching lines @@
   // do YUV decoding.
   std::unique_ptr<ImagePlanes> dummy_image_planes =
       WTF::WrapUnique(new ImagePlanes);
   decoder->SetImagePlanes(std::move(dummy_image_planes));
 
   return UpdateYUVComponentSizes(decoder.get(), size_info->fSizes,
                                  size_info->fWidthBytes);
 }
 
 }  // namespace blink