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& scaledSize,
+                   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. Decoder alpha option

[scroggo_chromium, 2017/04/10 17:31:24]

nit: Maybe be explicit that this is AlphaOption?

[msarett1, 2017/04/10 21:34:26]

Done.

+  typedef std::pair<const ImageFrameGenerator*, std::pair<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 {
       TypeDecoder,
@@ 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)));
     }
 
-    DecoderCacheEntry(const ImageFrameGenerator* generator,
-                      int count,
-                      std::unique_ptr<ImageDecoder> decoder)
-        : CacheEntry(generator, count),
-          m_cachedDecoder(std::move(decoder)),
-          m_size(SkISize::Make(m_cachedDecoder->decodedSize().width(),
-                               m_cachedDecoder->decodedSize().height())) {}
-
     size_t memoryUsageInBytes() const override {
       return m_size.width() * m_size.height() * 4;
     }
     CacheType type() const override { return TypeDecoder; }
 
     static DecoderCacheKey makeCacheKey(const ImageFrameGenerator* generator,
-                                        const SkISize& size) {
-      return std::make_pair(generator, size);
+                                        const SkISize& size,
+                                        ImageDecoder::AlphaOption alphaOption) {
+      return std::make_pair(generator,
+                            std::make_pair(size, (uint8_t)alphaOption));

[scroggo_chromium, 2017/04/10 17:31:24]

nit: C++ style cast

[msarett1, 2017/04/10 21:34:26]

Done.

     }
     static DecoderCacheKey makeCacheKey(const ImageFrameGenerator* generator,
                                         const ImageDecoder* decoder) {
-      return std::make_pair(generator,
-                            SkISize::Make(decoder->decodedSize().width(),
-                                          decoder->decodedSize().height()));
+      return makeCacheKey(generator,
+                          SkISize::Make(decoder->decodedSize().width(),
+                                        decoder->decodedSize().height()),
+                          decoder->alphaOption());
     }
     DecoderCacheKey cacheKey() const {
-      return makeCacheKey(m_generator, m_size);
+      return makeCacheKey(m_generator, m_size, m_alphaOption);
     }
     ImageDecoder* cachedDecoder() const { return m_cachedDecoder.get(); }
 
    private:
+    DecoderCacheEntry(const ImageFrameGenerator* generator,
+                      int count,
+                      std::unique_ptr<ImageDecoder> decoder)
+        : CacheEntry(generator, count),
+          m_cachedDecoder(std::move(decoder)),
+          m_size(SkISize::Make(m_cachedDecoder->decodedSize().width(),
+                               m_cachedDecoder->decodedSize().height())) {
+      m_alphaOption = m_cachedDecoder->alphaOption();

[scroggo_chromium, 2017/04/10 17:31:24]

nit: This could go in the initializer list.

(See my new comment in your earlier patch set.)

[msarett1, 2017/04/10 21:34:26]

Yes of course, you're right.  Thanks.

+    }
+
     std::unique_ptr<ImageDecoder> m_cachedDecoder;
     SkISize m_size;
+    ImageDecoder::AlphaOption m_alphaOption;
   };
 
   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> cacheEntry,
                            U* cacheMap,
@@ 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 m_mutex;
 };
 
 }  // namespace blink
 
 #endif