respect srgb gamma when building mips

src/core/SkBitmapCache.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkImage.h"
 #include "SkResourceCache.h"
@@ skipping 212 matching lines @@
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////
 
 namespace {
 static unsigned gMipMapKeyNamespaceLabel;
 
 struct MipMapKey : public SkResourceCache::Key {
 public:
-    MipMapKey(uint32_t genID, const SkIRect& bounds) : fGenID(genID), fBounds(bounds) {
+    MipMapKey(uint32_t genID, SkSourceGammaTreatment treatment, const SkIRect& bounds)
+        : fGenID(genID), fSrcGammaTreatment(static_cast<uint32_t>(treatment)), fBounds(bounds)
+    {
         this->init(&gMipMapKeyNamespaceLabel, SkMakeResourceCacheSharedIDForBitmap(genID),
-                   sizeof(fGenID) + sizeof(fBounds));
+                   sizeof(fGenID) + sizeof(fSrcGammaTreatment) + sizeof(fBounds));
     }
 
     uint32_t    fGenID;
+    uint32_t    fSrcGammaTreatment;
     SkIRect     fBounds;
 };
 
 struct MipMapRec : public SkResourceCache::Rec {
-    MipMapRec(const SkBitmap& src, const SkMipMap* result)
-        : fKey(src.getGenerationID(), get_bounds_from_bitmap(src))
+    MipMapRec(const SkBitmap& src, SkSourceGammaTreatment treatment, const SkMipMap* result)
+        : fKey(src.getGenerationID(), treatment, get_bounds_from_bitmap(src))
         , fMipMap(result)
     {
         fMipMap->attachToCacheAndRef();
     }
 
     virtual ~MipMapRec() {
         fMipMap->detachFromCacheAndUnref();
     }
 
     const Key& getKey() const override { return fKey; }
@@ skipping 17 matching lines @@
         return true;
     }
 
 private:
     MipMapKey       fKey;
     const SkMipMap* fMipMap;
 };
 }
 
 const SkMipMap* SkMipMapCache::FindAndRef(const SkBitmapCacheDesc& desc,
+                                          SkSourceGammaTreatment treatment,
                                           SkResourceCache* localCache) {
     // Note: we ignore width/height from desc, just need id and bounds
-    MipMapKey key(desc.fImageID, desc.fBounds);
+    MipMapKey key(desc.fImageID, treatment, desc.fBounds);
     const SkMipMap* result;
 
     if (!CHECK_LOCAL(localCache, find, Find, key, MipMapRec::Finder, &result)) {
         result = nullptr;
     }
     return result;
 }
 
 static SkResourceCache::DiscardableFactory get_fact(SkResourceCache* localCache) {
     return localCache ? localCache->GetDiscardableFactory()
                       : SkResourceCache::GetDiscardableFactory();
 }
 
-const SkMipMap* SkMipMapCache::AddAndRef(const SkBitmap& src, SkResourceCache* localCache) {
-    SkMipMap* mipmap = SkMipMap::Build(src, get_fact(localCache));
+const SkMipMap* SkMipMapCache::AddAndRef(const SkBitmap& src, SkSourceGammaTreatment treatment,
+                                         SkResourceCache* localCache) {
+    SkMipMap* mipmap = SkMipMap::Build(src, treatment, get_fact(localCache));
     if (mipmap) {
-        MipMapRec* rec = new MipMapRec(src, mipmap);
+        MipMapRec* rec = new MipMapRec(src, treatment, mipmap);
         CHECK_LOCAL(localCache, add, Add, rec);
         src.pixelRef()->notifyAddedToCache();
     }
     return mipmap;
 }