Respect colorSpace in DecodingImageGenerator::onGetPixels()

third_party/WebKit/Source/platform/graphics/ImageFrameGeneratorTest.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
@@ skipping 115 matching lines @@
   ImageFrame::Status next_frame_status_;
   size_t frame_count_;
   size_t requested_clear_except_frame_;
 };
 
 TEST_F(ImageFrameGeneratorTest, incompleteDecode) {
   SetFrameStatus(ImageFrame::kFramePartial);
 
   char buffer[100 * 100 * 4];
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(1, decode_request_count_);
 
   AddNewData();
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(2, decode_request_count_);
   EXPECT_EQ(0, decoders_destroyed_);
 }
 
 TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesComplete) {
   SetFrameStatus(ImageFrame::kFramePartial);
 
   char buffer[100 * 100 * 4];
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(1, decode_request_count_);
   EXPECT_EQ(0, decoders_destroyed_);
 
   SetFrameStatus(ImageFrame::kFrameComplete);
   AddNewData();
 
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(2, decode_request_count_);
   EXPECT_EQ(1, decoders_destroyed_);
 
   // Decoder created again.
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(3, decode_request_count_);
 }
 
 static void DecodeThreadMain(ImageFrameGenerator* generator,
                              SegmentReader* segment_reader) {
   char buffer[100 * 100 * 4];
   generator->DecodeAndScale(segment_reader, false, 0, ImageInfo(), buffer,
-                            100 * 4);
+                            100 * 4, ImageDecoder::kAlphaPremultiplied);
 }
 
 TEST_F(ImageFrameGeneratorTest, incompleteDecodeBecomesCompleteMultiThreaded) {
   SetFrameStatus(ImageFrame::kFramePartial);
 
   char buffer[100 * 100 * 4];
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(1, decode_request_count_);
   EXPECT_EQ(0, decoders_destroyed_);
 
   // LocalFrame can now be decoded completely.
   SetFrameStatus(ImageFrame::kFrameComplete);
   AddNewData();
   std::unique_ptr<WebThread> thread =
       WTF::WrapUnique(Platform::Current()->CreateThread("DecodeThread"));
   thread->GetWebTaskRunner()->PostTask(
       BLINK_FROM_HERE,
       CrossThreadBind(&DecodeThreadMain, generator_, segment_reader_));
   thread.reset();
   EXPECT_EQ(2, decode_request_count_);
   EXPECT_EQ(1, decoders_destroyed_);
 
   // Decoder created again.
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(3, decode_request_count_);
 
   AddNewData();
 
   // Delete generator.
   generator_ = nullptr;
 }
 
 TEST_F(ImageFrameGeneratorTest, frameHasAlpha) {
   SetFrameStatus(ImageFrame::kFramePartial);
 
   char buffer[100 * 100 * 4];
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_TRUE(generator_->HasAlpha(0));
   EXPECT_EQ(1, decode_request_count_);
 
   ImageDecoder* temp_decoder = 0;
   EXPECT_TRUE(ImageDecodingStore::Instance().LockDecoder(
-      generator_.Get(), FullSize(), &temp_decoder));
+      generator_.Get(), FullSize(), ImageDecoder::kAlphaPremultiplied,
+      &temp_decoder));
   ASSERT_TRUE(temp_decoder);
   temp_decoder->FrameBufferAtIndex(0)->SetHasAlpha(false);
   ImageDecodingStore::Instance().UnlockDecoder(generator_.Get(), temp_decoder);
   EXPECT_EQ(2, decode_request_count_);
 
   SetFrameStatus(ImageFrame::kFrameComplete);
   generator_->DecodeAndScale(segment_reader_.Get(), false, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(3, decode_request_count_);
   EXPECT_FALSE(generator_->HasAlpha(0));
 }
 
 TEST_F(ImageFrameGeneratorTest, clearMultiFrameDecoder) {
   SetFrameCount(3);
   SetFrameStatus(ImageFrame::kFrameComplete);
 
   char buffer[100 * 100 * 4];
   generator_->DecodeAndScale(segment_reader_.Get(), true, 0, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(1, decode_request_count_);
   EXPECT_EQ(0, decoders_destroyed_);
   EXPECT_EQ(0U, requested_clear_except_frame_);
 
   SetFrameStatus(ImageFrame::kFrameComplete);
 
   generator_->DecodeAndScale(segment_reader_.Get(), true, 1, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(2, decode_request_count_);
   EXPECT_EQ(0, decoders_destroyed_);
   EXPECT_EQ(1U, requested_clear_except_frame_);
 
   SetFrameStatus(ImageFrame::kFrameComplete);
 
   // Decoding the last frame of a multi-frame images should trigger clearing
   // all the frame data, but not destroying the decoder.  See comments in
   // ImageFrameGenerator::tryToResumeDecode().
   generator_->DecodeAndScale(segment_reader_.Get(), true, 2, ImageInfo(),
-                             buffer, 100 * 4);
+                             buffer, 100 * 4,
+                             ImageDecoder::kAlphaPremultiplied);
   EXPECT_EQ(3, decode_request_count_);
   EXPECT_EQ(0, decoders_destroyed_);
   EXPECT_EQ(kNotFound, requested_clear_except_frame_);
 }
 
 }  // namespace blink