Respect colorSpace in DecodingImageGenerator::onGetPixels()

third_party/WebKit/Source/platform/graphics/ImageDecodingStore.h

 /*
  * 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 60 matching lines @@
   }
   ~ImageDecodingStore();
 
   static ImageDecodingStore& Instance();
 
   // Accesses a cached decoder object. A decoder is indexed by origin
   // (ImageFrameGenerator) and scaled size. Returns true if the cached object is
   // found.
   bool LockDecoder(const ImageFrameGenerator*,
                    const SkISize& scaled_size,
+                   ImageDecoder::AlphaOption,
                    ImageDecoder**);
   void UnlockDecoder(const ImageFrameGenerator*, const ImageDecoder*);
   void InsertDecoder(const ImageFrameGenerator*, std::unique_ptr<ImageDecoder>);
   void RemoveDecoder(const ImageFrameGenerator*, const ImageDecoder*);
 
   // Remove all cache entries indexed by ImageFrameGenerator.
   void RemoveCacheIndexedByGenerator(const ImageFrameGenerator*);
 
   void Clear();
   void SetCacheLimitInBytes(size_t);
   size_t MemoryUsageInBytes();
   int CacheEntries();
   int DecoderCacheEntries();
 
  private:
   // Decoder cache entry is identified by:
   // 1. Pointer to ImageFrameGenerator.
   // 2. Size of the image.
-  typedef std::pair<const ImageFrameGenerator*, SkISize> DecoderCacheKey;
+  // 3. ImageDecoder::AlphaOption
+  typedef std::tuple<const ImageFrameGenerator*, SkISize, uint8_t>
+      DecoderCacheKey;
 
   // Base class for all cache entries.
   class CacheEntry : public DoublyLinkedListNode<CacheEntry> {
     USING_FAST_MALLOC(CacheEntry);
     WTF_MAKE_NONCOPYABLE(CacheEntry);
     friend class WTF::DoublyLinkedListNode<CacheEntry>;
 
    public:
     enum CacheType {
       kTypeDecoder,
@@ skipping 28 matching lines @@
 
   class DecoderCacheEntry final : public CacheEntry {
    public:
     static std::unique_ptr<DecoderCacheEntry> Create(
         const ImageFrameGenerator* generator,
         std::unique_ptr<ImageDecoder> decoder) {
       return WTF::WrapUnique(
           new DecoderCacheEntry(generator, 0, std::move(decoder)));
     }
 
+    size_t MemoryUsageInBytes() const override {
+      return size_.width() * size_.height() * 4;
+    }
+    CacheType GetType() const override { return kTypeDecoder; }
+
+    static DecoderCacheKey MakeCacheKey(
+        const ImageFrameGenerator* generator,
+        const SkISize& size,
+        ImageDecoder::AlphaOption alpha_option) {
+      return std::make_tuple(generator, size,
+                             static_cast<uint8_t>(alpha_option));
+    }
+    static DecoderCacheKey MakeCacheKey(const ImageFrameGenerator* generator,
+                                        const ImageDecoder* decoder) {
+      return MakeCacheKey(generator,
+                          SkISize::Make(decoder->DecodedSize().Width(),
+                                        decoder->DecodedSize().Height()),
+                          decoder->AlphaOpt());
+    }
+    DecoderCacheKey CacheKey() const {
+      return MakeCacheKey(generator_, size_, alpha_option_);
+    }
+    ImageDecoder* CachedDecoder() const { return cached_decoder_.get(); }
+
+   private:
     DecoderCacheEntry(const ImageFrameGenerator* generator,
                       int count,
                       std::unique_ptr<ImageDecoder> decoder)
         : CacheEntry(generator, count),
           cached_decoder_(std::move(decoder)),
           size_(SkISize::Make(cached_decoder_->DecodedSize().Width(),
-                              cached_decoder_->DecodedSize().Height())) {}
+                              cached_decoder_->DecodedSize().Height())),
+          alpha_option_(cached_decoder_->AlphaOpt()) {}
 
-    size_t MemoryUsageInBytes() const override {
-      return size_.width() * size_.height() * 4;
-    }
-    CacheType GetType() const override { return kTypeDecoder; }
-
-    static DecoderCacheKey MakeCacheKey(const ImageFrameGenerator* generator,
-                                        const SkISize& size) {
-      return std::make_pair(generator, size);
-    }
-    static DecoderCacheKey MakeCacheKey(const ImageFrameGenerator* generator,
-                                        const ImageDecoder* decoder) {
-      return std::make_pair(generator,
-                            SkISize::Make(decoder->DecodedSize().Width(),
-                                          decoder->DecodedSize().Height()));
-    }
-    DecoderCacheKey CacheKey() const { return MakeCacheKey(generator_, size_); }
-    ImageDecoder* CachedDecoder() const { return cached_decoder_.get(); }
-
-   private:
     std::unique_ptr<ImageDecoder> cached_decoder_;
     SkISize size_;
+    ImageDecoder::AlphaOption alpha_option_;
   };
 
   ImageDecodingStore();
 
   void Prune();
 
   // These helper methods are called while m_mutex is locked.
   template <class T, class U, class V>
   void InsertCacheInternal(std::unique_ptr<T> cache_entry,
                            U* cache_map,
@@ skipping 57 matching lines @@
   //   m_heapLimitInBytes
   //   m_heapMemoryUsageInBytes
   // This mutex also protects calls to underlying skBitmap's
   // lockPixels()/unlockPixels() as they are not threadsafe.
   Mutex mutex_;
 };
 
 }  // namespace blink
 
 #endif