Preserve color space of images in deferred texture API

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <cstddef>
 #include <cstring>
 #include <type_traits>
@@ skipping 474 matching lines @@
             ctSize = SkAlign8(pixmap.ctable()->count() * 4);
         }
     } else {
         // Here we're just using presence of data to know whether there is a codec behind the image.
         // In the future we will access the cacherator and get the exact data that we want to (e.g.
         // yuv planes) upload.
         sk_sp<SkData> data(this->refEncoded());
         if (!data && !this->peekPixels(nullptr)) {
             return 0;
         }
-        info = SkImageInfo::MakeN32(scaledSize.width(), scaledSize.height(), this->alphaType());
+        info = as_IB(this)->onImageInfo().makeWH(scaledSize.width(), scaledSize.height());
         pixelSize = SkAlign8(SkAutoPixmapStorage::AllocSize(info, nullptr));
         if (fillMode) {
             pixmap.alloc(info);
             if (isScaled) {
                 if (!this->scalePixels(pixmap, scaleFilterQuality,
                                        SkImage::kDisallow_CachingHint)) {
                     return 0;
                 }
             } else {
                 if (!this->readPixels(pixmap, 0, 0, SkImage::kDisallow_CachingHint)) {
                     return 0;
                 }
             }
             SkASSERT(!pixmap.ctable());
         }
     }
-    SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
     int mipMapLevelCount = 1;
     if (useMipMaps) {
         // SkMipMap only deals with the mipmap levels it generates, which does
         // not include the base level.
         // That means it generates and holds levels 1-x instead of 0-x.
         // So the total mipmap level count is 1 more than what
         // SkMipMap::ComputeLevelCount returns.
         mipMapLevelCount = SkMipMap::ComputeLevelCount(scaledSize.width(), scaledSize.height()) + 1;
 
         // We already initialized pixelSize to the size of the base level.
         // SkMipMap will generate the extra mipmap levels. Their sizes need to
         // be added to the total.
         // Index 0 here does not refer to the base mipmap level -- it is
         // SkMipMap's first generated mipmap level (level 1).
         for (int currentMipMapLevelIndex = mipMapLevelCount - 2; currentMipMapLevelIndex >= 0;
              currentMipMapLevelIndex--) {
             SkISize mipSize = SkMipMap::ComputeLevelSize(scaledSize.width(), scaledSize.height(),
                                                          currentMipMapLevelIndex);
-            SkImageInfo mipInfo = SkImageInfo::MakeN32(mipSize.fWidth, mipSize.fHeight, at);
+            SkImageInfo mipInfo = info.makeWH(mipSize.fWidth, mipSize.fHeight);
             pixelSize += SkAlign8(SkAutoPixmapStorage::AllocSize(mipInfo, nullptr));
         }
     }
     size_t size = 0;
     size_t dtiSize = SkAlign8(sizeof(DeferredTextureImage));
     size += dtiSize;
     size += (mipMapLevelCount - 1) * sizeof(MipMapLevelData);
     // We subtract 1 because DeferredTextureImage already includes the base
     // level in its size
     size_t pixelOffset = size;
@@ skipping 65 matching lines @@
         static_assert(std::is_standard_layout<MipMapLevelData>::value,
                       "offsetof, which we use below, requires the type have a standard layout");
 
         SkAutoTDelete<SkMipMap> mipmaps(SkMipMap::Build(pixmap, gammaTreatment, nullptr));
         // SkMipMap holds only the mipmap levels it generates.
         // A programmer can use the data they provided to SkMipMap::Build as level 0.
         // So the SkMipMap provides levels 1-x but it stores them in its own
         // range 0-(x-1).
         for (int generatedMipLevelIndex = 0; generatedMipLevelIndex < mipMapLevelCount - 1;
              generatedMipLevelIndex++) {
-            SkISize mipSize = SkMipMap::ComputeLevelSize(scaledSize.width(), scaledSize.height(),
-                                                         generatedMipLevelIndex);
-
-            SkImageInfo mipInfo = SkImageInfo::MakeN32(mipSize.fWidth, mipSize.fHeight, at);
             SkMipMap::Level mipLevel;
             mipmaps->getLevel(generatedMipLevelIndex, &mipLevel);
 
             // Make sure the mipmap data is after the start of the buffer
             SkASSERT(mipLevelPtr > bufferAsCharPtr);
             // Make sure the mipmap data starts before the end of the buffer
             SkASSERT(mipLevelPtr < bufferAsCharPtr + pixelOffset + pixelSize);
             // Make sure the mipmap data ends before the end of the buffer
             SkASSERT(mipLevelPtr + mipLevel.fPixmap.getSafeSize() <=
                      bufferAsCharPtr + pixelOffset + pixelSize);
@@ skipping 69 matching lines @@
     }
     SkAutoTUnref<GrTexture> texture(GrUploadMipMapToTexture(ctx, info, texels, mipLevelCount));
     if (!texture) {
         return nullptr;
     }
     texture->texturePriv().setGammaTreatment(gammaTreatment);
     return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNewImageUniqueID,
                                    info.alphaType(), texture, sk_ref_sp(info.colorSpace()),
                                    budgeted);
 }