Add alphaType() to SkImage

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 "SkAutoPixmapStorage.h"
 #include "GrCaps.h"
 #include "GrContext.h"
@@ skipping 33 matching lines @@
 }
 
 SkImageInfo SkImage_Gpu::onImageInfo() const {
     SkColorType ct;
     if (!GrPixelConfigToColorType(fTexture->config(), &ct)) {
         ct = kUnknown_SkColorType;
     }
     return SkImageInfo::Make(fTexture->width(), fTexture->height(), ct, fAlphaType, fColorSpace);
 }
 
-static SkImageInfo make_info(int w, int h, bool isOpaque, sk_sp<SkColorSpace> colorSpace) {
-    return SkImageInfo::MakeN32(w, h, isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType,
-                                std::move(colorSpace));
+static SkImageInfo make_info(int w, int h, SkAlphaType at, sk_sp<SkColorSpace> colorSpace) {
+    return SkImageInfo::MakeN32(w, h, at, std::move(colorSpace));
 }
 
 bool SkImage_Gpu::getROPixels(SkBitmap* dst, CachingHint chint) const {
     if (SkBitmapCache::Find(this->uniqueID(), dst)) {
         SkASSERT(dst->getGenerationID() == this->uniqueID());
         SkASSERT(dst->isImmutable());
         SkASSERT(dst->getPixels());
         return true;
     }
 
-    if (!dst->tryAllocPixels(make_info(this->width(), this->height(), this->isOpaque(),
+    if (!dst->tryAllocPixels(make_info(this->width(), this->height(), this->alphaType(),
                                        this->fColorSpace))) {
         return false;
     }
     if (!fTexture->readPixels(0, 0, dst->width(), dst->height(), kSkia8888_GrPixelConfig,
                               dst->getPixels(), dst->rowBytes())) {
         return false;
     }
 
     dst->pixelRef()->setImmutableWithID(this->uniqueID());
     if (kAllow_CachingHint == chint) {
         SkBitmapCache::Add(this->uniqueID(), *dst);
         fAddedRasterVersionToCache.store(true);
     }
     return true;
 }
 
 GrTexture* SkImage_Gpu::asTextureRef(GrContext* ctx, const GrTextureParams& params,
                                      SkSourceGammaTreatment gammaTreatment) const {
     GrTextureAdjuster adjuster(this->peekTexture(), this->bounds(), this->uniqueID(),
                                this->onImageInfo().colorSpace());
     return adjuster.refTextureSafeForParams(params, gammaTreatment, nullptr);
 }
 
-bool SkImage_Gpu::isOpaque() const {
-    return GrPixelConfigIsOpaque(fTexture->config()) || fAlphaType == kOpaque_SkAlphaType;
-}
-
 static void apply_premul(const SkImageInfo& info, void* pixels, size_t rowBytes) {
     switch (info.colorType()) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType:
             break;
         default:
             return; // nothing to do
     }
 
     // SkColor is not necesarily RGBA or BGRA, but it is one of them on little-endian,
@@ skipping 197 matching lines @@
                                    sk_ref_sp(maker->getColorSpace()), SkBudgeted::kNo);
 }
 
 sk_sp<SkImage> SkImage::makeTextureImage(GrContext *context) const {
     if (!context) {
         return nullptr;
     }
     if (GrTexture* peek = as_IB(this)->peekTexture()) {
         return peek->getContext() == context ? sk_ref_sp(const_cast<SkImage*>(this)) : nullptr;
     }
-    // No way to check whether a image is premul or not?
-    SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
 
     if (SkImageCacherator* cacher = as_IB(this)->peekCacherator()) {
         GrImageTextureMaker maker(context, cacher, this, kDisallow_CachingHint);
-        return create_image_from_maker(&maker, at, this->uniqueID());
+        return create_image_from_maker(&maker, this->alphaType(), this->uniqueID());
     }
 
     if (const SkBitmap* bmp = as_IB(this)->onPeekBitmap()) {
         GrBitmapTextureMaker maker(context, *bmp);
-        return create_image_from_maker(&maker, at, this->uniqueID());
+        return create_image_from_maker(&maker, this->alphaType(), this->uniqueID());
     }
     return nullptr;
 }
 
 sk_sp<SkImage> SkImage::makeNonTextureImage() const {
     if (!this->isTextureBacked()) {
         return sk_ref_sp(const_cast<SkImage*>(this));
     }
     SkImageInfo info = as_IB(this)->onImageInfo();
     size_t rowBytes = info.minRowBytes();
@@ skipping 105 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;
         }
-        SkAlphaType at = this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-        info = SkImageInfo::MakeN32(scaledSize.width(), scaledSize.height(), at);
+        info = SkImageInfo::MakeN32(scaledSize.width(), scaledSize.height(), this->alphaType());
         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)) {
@@ skipping 111 matching lines @@
         return nullptr;
     }
     SkAutoTUnref<GrTexture> texture(GrUploadMipMapToTexture(ctx, info, texels, mipLevelCount));
     if (!texture) {
         return nullptr;
     }
     return sk_make_sp<SkImage_Gpu>(texture->width(), texture->height(), kNeedNewImageUniqueID,
                                    info.alphaType(), texture, sk_ref_sp(info.colorSpace()),
                                    budgeted);
 }