store SkAlphaType inside SkBitmap, on road to support unpremul

BUG=
R=bsalomon@google.com, scroggo@google.com

Review URL: https://codereview.chromium.org/25275004

git-svn-id: http://skia.googlecode.com/svn/trunk@11877 2bbb7eff-a529-9590-31e7-b0007b416f81

39 files changed, 206 insertions, 224 deletions

diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index 982c917c02..6dc759283e 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -126,7 +126,7 @@ protected:
             fBitmap = bm;
         }
 
-        fBitmap.setIsOpaque(fIsOpaque);
+        fBitmap.setAlphaType(fIsOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
         fBitmap.setIsVolatile(fIsVolatile);
     }
 
diff --git a/bench/BitmapRectBench.cpp b/bench/BitmapRectBench.cpp
index 1dd98ef975..104cb24bd9 100644
--- a/bench/BitmapRectBench.cpp
+++ b/bench/BitmapRectBench.cpp
@@ -66,7 +66,7 @@ protected:
 
     virtual void onPreDraw() SK_OVERRIDE {
         fBitmap.allocPixels();
-        fBitmap.setIsOpaque(true);
+        fBitmap.setAlphaType(kOpaque_SkAlphaType);
         fBitmap.eraseColor(SK_ColorBLACK);
         draw_into_bitmap(fBitmap);
 
diff --git a/bench/BitmapScaleBench.cpp b/bench/BitmapScaleBench.cpp
index cc2a33a894..ae3df71c22 100644
--- a/bench/BitmapScaleBench.cpp
+++ b/bench/BitmapScaleBench.cpp
@@ -57,14 +57,14 @@ protected:
     }
 
     virtual void onPreDraw() {
-        fInputBitmap.setConfig(SkBitmap::kARGB_8888_Config, fInputSize, fInputSize);
+        fInputBitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                               fInputSize, fInputSize, 0, kOpaque_SkAlphaType);
         fInputBitmap.allocPixels();
         fInputBitmap.eraseColor(SK_ColorWHITE);
-        fInputBitmap.setIsOpaque(true);
 
-        fOutputBitmap.setConfig(SkBitmap::kARGB_8888_Config, fOutputSize, fOutputSize);
+        fOutputBitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                                fOutputSize, fOutputSize, 0, kOpaque_SkAlphaType);
         fOutputBitmap.allocPixels();
-        fOutputBitmap.setIsOpaque(true);
 
         fMatrix.setScale( scale(), scale() );
     }
diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp
index 612a149d6d..957ec2a83e 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp
@@ -115,7 +115,8 @@ protected:
     virtual void onPreDraw() SK_OVERRIDE {
         fBitmap.allocPixels();
         fBitmap.eraseColor(fIsOpaque ? SK_ColorWHITE : 0);
-        fBitmap.setIsOpaque(fIsOpaque);
+        fBitmap.setAlphaType(fIsOpaque ?
+                             kOpaque_SkAlphaType : kPremul_SkAlphaType);
 
         draw_into_bitmap(fBitmap);
 
diff --git a/bench/TileBench.cpp b/bench/TileBench.cpp
index 60312a3d56..03a758cdea 100644
--- a/bench/TileBench.cpp
+++ b/bench/TileBench.cpp
@@ -48,11 +48,10 @@ public:
         , fDoScale(doScale) {
         SkBitmap bm;
 
-        bm.setConfig(SkBitmap::kARGB_8888_Config, kWidth, kHeight);
-
+        bm.setConfig(SkBitmap::kARGB_8888_Config, kWidth, kHeight, 0,
+                     kOpaque_SkAlphaType);
         bm.allocPixels();
         bm.eraseColor(SK_ColorWHITE);
-        bm.setIsOpaque(true);
 
         create_gradient(&bm);
 
diff --git a/gm/bleed.cpp b/gm/bleed.cpp
index dc7e96fbb1..0d093940de 100644
--- a/gm/bleed.cpp
+++ b/gm/bleed.cpp
@@ -19,7 +19,8 @@
 static void make_red_ringed_bitmap(SkBitmap* result, int width, int height) {
     SkASSERT(0 == width % 2 && 0 == width % 2);
 
-    result->setConfig(SkBitmap::kARGB_8888_Config, width, height);
+    result->setConfig(SkBitmap::kARGB_8888_Config, width, height, 0,
+                      kOpaque_SkAlphaType);
     result->allocPixels();
     SkAutoLockPixels lock(*result);
 
@@ -56,7 +57,6 @@ static void make_red_ringed_bitmap(SkBitmap* result, int width, int height) {
     for (int x = 0; x < width; ++x) {
         scanline[x] = SK_ColorRED;
     }
-    result->setIsOpaque(true);
     result->setImmutable();
 }
 
diff --git a/gm/xfermodes.cpp b/gm/xfermodes.cpp
index 65f53bffe7..e839b0ee71 100644
--- a/gm/xfermodes.cpp
+++ b/gm/xfermodes.cpp
@@ -60,9 +60,8 @@ class XfermodesGM : public GM {
     }
 
     virtual void onOnceBeforeDraw() SK_OVERRIDE {
-        fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4);
+        fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4, kOpaque_SkAlphaType);
         fBG.setPixels(gData);
-        fBG.setIsOpaque(true);
 
         make_bitmaps(W, H, &fSrcB, &fDstB);
     }
diff --git a/gm/xfermodes2.cpp b/gm/xfermodes2.cpp
index 990ee508d5..046c3ddc2a 100644
--- a/gm/xfermodes2.cpp
+++ b/gm/xfermodes2.cpp
@@ -93,11 +93,10 @@ private:
             SkPackARGB32(0xFF, 0x40, 0x40, 0x40)
         };
         SkBitmap bg;
-        bg.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
+        bg.setConfig(SkBitmap::kARGB_8888_Config, 2, 2, 0, kOpaque_SkAlphaType);
         bg.allocPixels();
         SkAutoLockPixels bgAlp(bg);
         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
-        bg.setIsOpaque(true);
 
         fBG.reset(SkShader::CreateBitmapShader(bg,
                                                SkShader::kRepeat_TileMode,
diff --git a/gm/xfermodes3.cpp b/gm/xfermodes3.cpp
index baac3cdaff..d01c0190d4 100644
--- a/gm/xfermodes3.cpp
+++ b/gm/xfermodes3.cpp
@@ -188,11 +188,10 @@ private:
             SkPackARGB32(0xFF, 0x40, 0x40, 0x40)
         };
         SkBitmap bg;
-        bg.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
+        bg.setConfig(SkBitmap::kARGB_8888_Config, 2, 2, 0, kOpaque_SkAlphaType);
         bg.allocPixels();
         SkAutoLockPixels bgAlp(bg);
         memcpy(bg.getPixels(), kCheckData, sizeof(kCheckData));
-        bg.setIsOpaque(true);
 
         fBGShader.reset(SkShader::CreateBitmapShader(bg,
                                                      SkShader::kRepeat_TileMode,
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index 07d2b95553..3e22069e60 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -11,6 +11,7 @@
 #define SkBitmap_DEFINED
 
 #include "Sk64.h"
+#include "SkAlpha.h"
 #include "SkColor.h"
 #include "SkColorTable.h"
 #include "SkPoint.h"
@@ -130,6 +131,15 @@ public:
     */
     int rowBytesAsPixels() const { return fRowBytes >> (fBytesPerPixel >> 1); }
 
+    SkAlphaType alphaType() const { return (SkAlphaType)fAlphaType; }
+
+    /**
+     *  Set the bitmap's alphaType, returning true on success. If false is
+     *  returned, then the specified new alphaType is incompatible with the
+     *  Config, and the current alphaType is unchanged.
+     */
+    bool setAlphaType(SkAlphaType);
+
     /** Return the address of the pixels for this SkBitmap.
     */
     void* getPixels() const { return fPixels; }
@@ -175,12 +185,16 @@ public:
 
     /** Returns true if the bitmap is opaque (has no translucent/transparent pixels).
     */
-    bool isOpaque() const;
+    bool isOpaque() const {
+        return SkAlphaTypeIsOpaque(this->alphaType());
+    }
 
-    /** Specify if this bitmap's pixels are all opaque or not. Is only meaningful for configs
-        that support per-pixel alpha (RGB32, A1, A8).
-    */
-    void setIsOpaque(bool);
+    /**
+     *  DEPRECATED: use setAlpahType() instead.
+     */
+    void setIsOpaque(bool opaque) {
+        this->setAlphaType(opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
+    }
 
     /** Returns true if the bitmap is volatile (i.e. should not be cached by devices.)
     */
@@ -232,13 +246,6 @@ public:
     static bool ComputeIsOpaque(const SkBitmap&);
 
     /**
-     *  Calls ComputeIsOpaque, and passes its result to setIsOpaque().
-     */
-    void computeAndSetOpaquePredicate() {
-        this->setIsOpaque(ComputeIsOpaque(*this));
-    }
-
-    /**
      *  Return the bitmap's bounds [0, 0, width, height] as an SkRect
      */
     void getBounds(SkRect* bounds) const;
@@ -248,7 +255,14 @@ public:
         ComputeRowBytes() is called to compute the optimal value. This resets
         any pixel/colortable ownership, just like reset().
     */
-    void setConfig(Config, int width, int height, size_t rowBytes = 0);
+    bool setConfig(Config, int width, int height, size_t rowBytes, SkAlphaType);
+
+    bool setConfig(Config config, int width, int height, size_t rowBytes = 0) {
+        return this->setConfig(config, width, height, rowBytes,
+                               kPremul_SkAlphaType);
+    }
+
+
     /** Use this to assign a new pixel address for an existing bitmap. This
         will automatically release any pixelref previously installed. Only call
         this if you are handling ownership/lifetime of the pixel memory.
@@ -672,6 +686,7 @@ private:
     uint32_t    fWidth;
     uint32_t    fHeight;
     uint8_t     fConfig;
+    uint8_t     fAlphaType;
     uint8_t     fFlags;
     uint8_t     fBytesPerPixel; // based on config
 
diff --git a/samplecode/SampleDitherBitmap.cpp b/samplecode/SampleDitherBitmap.cpp
index 7f29305a51..9132ceb195 100644
--- a/samplecode/SampleDitherBitmap.cpp
+++ b/samplecode/SampleDitherBitmap.cpp
@@ -100,7 +100,7 @@ protected:
 
     static void setBitmapOpaque(SkBitmap* bm, bool isOpaque) {
         SkAutoLockPixels alp(*bm);  // needed for ctable
-        bm->setIsOpaque(isOpaque);
+        bm->setAlphaType(isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 #if 0
         SkColorTable* ctable = bm->getColorTable();
         if (ctable) {
diff --git a/samplecode/SampleTinyBitmap.cpp b/samplecode/SampleTinyBitmap.cpp
index 42866d07ad..dc7157ff99 100644
--- a/samplecode/SampleTinyBitmap.cpp
+++ b/samplecode/SampleTinyBitmap.cpp
@@ -57,9 +57,8 @@ protected:
 
     static void setBitmapOpaque(SkBitmap* bm, bool isOpaque) {
         SkAutoLockPixels alp(*bm);  // needed for ctable
-        bm->setIsOpaque(isOpaque);
+        bm->setAlphaType(isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 #if 0
-        // TODO - I think we just want to not allow this anymore
         SkColorTable* ctable = bm->getColorTable();
         if (ctable) {
             ctable->setIsOpaque(isOpaque);
diff --git a/samplecode/SampleXfermodesBlur.cpp b/samplecode/SampleXfermodesBlur.cpp
index 59aa87e214..a73d9f2e20 100644
--- a/samplecode/SampleXfermodesBlur.cpp
+++ b/samplecode/SampleXfermodesBlur.cpp
@@ -77,9 +77,8 @@ public:
     const static int W = 64;
     const static int H = 64;
     XfermodesBlurView() {
-        fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4);
+        fBG.setConfig(SkBitmap::kARGB_4444_Config, 2, 2, 4, kOpaque_SkAlphaType);
         fBG.setPixels(gBG);
-        fBG.setIsOpaque(true);
     }
 
 protected:
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 63a760c4cf..bad63bac18 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -143,6 +143,7 @@ void SkBitmap::swap(SkBitmap& other) {
     SkTSwap(fWidth, other.fWidth);
     SkTSwap(fHeight, other.fHeight);
     SkTSwap(fConfig, other.fConfig);
+    SkTSwap(fAlphaType, other.fAlphaType);
     SkTSwap(fFlags, other.fFlags);
     SkTSwap(fBytesPerPixel, other.fBytesPerPixel);
 
@@ -266,33 +267,76 @@ void SkBitmap::getBounds(SkIRect* bounds) const {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkBitmap::setConfig(Config c, int width, int height, size_t rowBytes) {
-    this->freePixels();
+static bool validate_alphaType(SkBitmap::Config config, SkAlphaType alphaType,
+                               SkAlphaType* canonical) {
+    switch (config) {
+        case SkBitmap::kNo_Config:
+            alphaType = kIgnore_SkAlphaType;
+            break;
+        case SkBitmap::kA1_Config:
+        case SkBitmap::kA8_Config:
+            if (kUnpremul_SkAlphaType == alphaType) {
+                alphaType = kPremul_SkAlphaType;
+            }
+            // fall-through
+        case SkBitmap::kIndex8_Config:
+        case SkBitmap::kARGB_4444_Config:
+        case SkBitmap::kARGB_8888_Config:
+            if (kIgnore_SkAlphaType == alphaType) {
+                return false;
+            }
+            break;
+        case SkBitmap::kRGB_565_Config:
+            alphaType = kOpaque_SkAlphaType;
+            break;
+    }
+    if (canonical) {
+        *canonical = alphaType;
+    }
+    return true;
+}
 
+bool SkBitmap::setConfig(Config config, int width, int height, size_t rowBytes,
+                         SkAlphaType alphaType) {
     if ((width | height) < 0) {
-        goto err;
+        goto ERROR;
     }
-
     if (rowBytes == 0) {
-        rowBytes = SkBitmap::ComputeRowBytes(c, width);
-        if (0 == rowBytes && kNo_Config != c) {
-            goto err;
+        rowBytes = SkBitmap::ComputeRowBytes(config, width);
+        if (0 == rowBytes && kNo_Config != config) {
+            goto ERROR;
         }
     }
 
-    fConfig     = SkToU8(c);
+    if (!validate_alphaType(config, alphaType, &alphaType)) {
+        goto ERROR;
+    }
+
+    this->freePixels();
+
+    fConfig     = SkToU8(config);
+    fAlphaType  = SkToU8(alphaType);
     fWidth      = width;
     fHeight     = height;
     fRowBytes   = SkToU32(rowBytes);
 
-    fBytesPerPixel = (uint8_t)ComputeBytesPerPixel(c);
+    fBytesPerPixel = (uint8_t)ComputeBytesPerPixel(config);
 
     SkDEBUGCODE(this->validate();)
-    return;
+    return true;
 
     // if we got here, we had an error, so we reset the bitmap to empty
-err:
+ERROR:
     this->reset();
+    return false;
+}
+
+bool SkBitmap::setAlphaType(SkAlphaType alphaType) {
+    if (!validate_alphaType(this->config(), alphaType, &alphaType)) {
+        return false;
+    }
+    fAlphaType = SkToU8(alphaType);
+    return true;
 }
 
 void SkBitmap::updatePixelsFromRef() const {
@@ -524,46 +568,6 @@ void SkBitmap::setImmutable() {
     }
 }
 
-bool SkBitmap::isOpaque() const {
-    switch (fConfig) {
-        case kNo_Config:
-            return true;
-
-        case kA1_Config:
-        case kA8_Config:
-        case kARGB_4444_Config:
-        case kARGB_8888_Config:
-            return (fFlags & kImageIsOpaque_Flag) != 0;
-
-        case kIndex8_Config: {
-            bool isOpaque;
-
-            this->lockPixels();
-            isOpaque = fColorTable && fColorTable->isOpaque();
-            this->unlockPixels();
-            return isOpaque;
-        }
-
-        case kRGB_565_Config:
-            return true;
-
-        default:
-            SkDEBUGFAIL("unknown bitmap config pased to isOpaque");
-            return false;
-    }
-}
-
-void SkBitmap::setIsOpaque(bool isOpaque) {
-    /*  we record this regardless of fConfig, though it is ignored in
-        isOpaque() for configs that can't support per-pixel alpha.
-    */
-    if (isOpaque) {
-        fFlags |= kImageIsOpaque_Flag;
-    } else {
-        fFlags &= ~kImageIsOpaque_Flag;
-    }
-}
-
 bool SkBitmap::isVolatile() const {
     return (fFlags & kImageIsVolatile_Flag) != 0;
 }
@@ -958,9 +962,9 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
         SkPixelRef* pixelRef = fPixelRef->deepCopy(this->config(), &subset);
         if (pixelRef != NULL) {
             SkBitmap dst;
-            dst.setConfig(this->config(), subset.width(), subset.height());
+            dst.setConfig(this->config(), subset.width(), subset.height(), 0,
+                          this->alphaType());
             dst.setIsVolatile(this->isVolatile());
-            dst.setIsOpaque(this->isOpaque());
             dst.setPixelRef(pixelRef)->unref();
             SkDEBUGCODE(dst.validate());
             result->swap(dst);
@@ -979,9 +983,9 @@ bool SkBitmap::extractSubset(SkBitmap* result, const SkIRect& subset) const {
     }
 
     SkBitmap dst;
-    dst.setConfig(this->config(), r.width(), r.height(), this->rowBytes());
+    dst.setConfig(this->config(), r.width(), r.height(), this->rowBytes(),
+                  this->alphaType());
     dst.setIsVolatile(this->isVolatile());
-    dst.setIsOpaque(this->isOpaque());
 
     if (fPixelRef) {
         // share the pixelref with a custom offset
@@ -1070,7 +1074,8 @@ bool SkBitmap::copyTo(SkBitmap* dst, Config dstConfig, Allocator* alloc) const {
     }
 
     SkBitmap tmpDst;
-    tmpDst.setConfig(dstConfig, src->width(), src->height());
+    tmpDst.setConfig(dstConfig, src->width(), src->height(), 0,
+                     src->alphaType());
 
     // allocate colortable if srcConfig == kIndex8_Config
     SkColorTable* ctable = (dstConfig == kIndex8_Config) ?
@@ -1130,8 +1135,6 @@ bool SkBitmap::copyTo(SkBitmap* dst, Config dstConfig, Allocator* alloc) const {
         canvas.drawBitmap(*src, 0, 0, &paint);
     }
 
-    tmpDst.setIsOpaque(src->isOpaque());
-
     dst->swap(tmpDst);
     return true;
 }
@@ -1579,7 +1582,7 @@ void SkBitmap::flatten(SkFlattenableWriteBuffer& buffer) const {
     buffer.writeInt(fHeight);
     buffer.writeInt(fRowBytes);
     buffer.writeInt(fConfig);
-    buffer.writeBool(this->isOpaque());
+    buffer.writeInt(fAlphaType);
 
     if (fPixelRef) {
         if (fPixelRef->getFactory()) {
@@ -1602,9 +1605,9 @@ void SkBitmap::unflatten(SkFlattenableReadBuffer& buffer) {
     int height = buffer.readInt();
     int rowBytes = buffer.readInt();
     int config = buffer.readInt();
+    int alphaType = buffer.readInt();
 
-    this->setConfig((Config)config, width, height, rowBytes);
-    this->setIsOpaque(buffer.readBool());
+    this->setConfig((Config)config, width, height, rowBytes, (SkAlphaType)alphaType);
 
     int reftype = buffer.readInt();
     switch (reftype) {
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index eee201881a..ff68481538 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -27,9 +27,9 @@ SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap, const SkDeviceProperties&
 }
 
 SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque) {
-    fBitmap.setConfig(config, width, height);
+    fBitmap.setConfig(config, width, height, 0, isOpaque ?
+                      kOpaque_SkAlphaType : kPremul_SkAlphaType);
     fBitmap.allocPixels();
-    fBitmap.setIsOpaque(isOpaque);
     if (!isOpaque) {
         fBitmap.eraseColor(SK_ColorTRANSPARENT);
     }
@@ -39,9 +39,9 @@ SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, b
                                const SkDeviceProperties& deviceProperties)
     : SkBaseDevice(deviceProperties) {
 
-    fBitmap.setConfig(config, width, height);
+    fBitmap.setConfig(config, width, height, 0, isOpaque ?
+                      kOpaque_SkAlphaType : kPremul_SkAlphaType);
     fBitmap.allocPixels();
-    fBitmap.setIsOpaque(isOpaque);
     if (!isOpaque) {
         fBitmap.eraseColor(SK_ColorTRANSPARENT);
     }
diff --git a/src/core/SkBitmapScaler.cpp b/src/core/SkBitmapScaler.cpp
index 114836dd79..c28d4779c7 100644
--- a/src/core/SkBitmapScaler.cpp
+++ b/src/core/SkBitmapScaler.cpp
@@ -287,7 +287,8 @@ bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
     // Convolve into the result.
     SkBitmap result;
     result.setConfig(SkBitmap::kARGB_8888_Config,
-        destSubset.width(), destSubset.height());
+                     destSubset.width(), destSubset.height(), 0,
+                     source.alphaType());
     result.allocPixels(allocator, NULL);
     if (!result.readyToDraw()) {
         return false;
@@ -299,8 +300,6 @@ bool SkBitmapScaler::Resize(SkBitmap* resultPtr,
         static_cast<unsigned char*>(result.getPixels()),
         convolveProcs, true);
 
-    // Preserve the "opaque" flag for use as an optimization later.
-    result.setIsOpaque(source.isOpaque());
     *resultPtr = result;
     return true;
 }
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 3c91101b34..1498fc4c42 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -137,14 +137,17 @@ static SkBitmap::Config grConfig2skConfig(GrPixelConfig config, bool* isOpaque)
     }
 }
 
+/*
+ * GrRenderTarget does not know its opaqueness, only its config, so we have
+ * to make conservative guesses when we return an "equivalent" bitmap.
+ */
 static SkBitmap make_bitmap(GrContext* context, GrRenderTarget* renderTarget) {
-    GrPixelConfig config = renderTarget->config();
-
     bool isOpaque;
+    SkBitmap::Config config = grConfig2skConfig(renderTarget->config(), &isOpaque);
+
     SkBitmap bitmap;
-    bitmap.setConfig(grConfig2skConfig(config, &isOpaque),
-                     renderTarget->width(), renderTarget->height());
-    bitmap.setIsOpaque(isOpaque);
+    bitmap.setConfig(config, renderTarget->width(), renderTarget->height(), 0,
+                     isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
     return bitmap;
 }
 
diff --git a/src/image/SkImagePriv.cpp b/src/image/SkImagePriv.cpp
index f707543c2a..eeeb9d87f7 100644
--- a/src/image/SkImagePriv.cpp
+++ b/src/image/SkImagePriv.cpp
@@ -9,45 +9,16 @@
 #include "SkCanvas.h"
 #include "SkPicture.h"
 
-SkBitmap::Config SkImageInfoToBitmapConfig(const SkImage::Info& info,
-                                           bool* isOpaque) {
+SkBitmap::Config SkImageInfoToBitmapConfig(const SkImage::Info& info) {
     switch (info.fColorType) {
         case SkImage::kAlpha_8_ColorType:
-            switch (info.fAlphaType) {
-                case kIgnore_SkAlphaType:
-                    // makes no sense
-                    return SkBitmap::kNo_Config;
-
-                case kOpaque_SkAlphaType:
-                    *isOpaque = true;
-                    return SkBitmap::kA8_Config;
-
-                case kPremul_SkAlphaType:
-                case kUnpremul_SkAlphaType:
-                    *isOpaque = false;
-                    return SkBitmap::kA8_Config;
-            }
-            break;
+            return SkBitmap::kA8_Config;
 
         case SkImage::kRGB_565_ColorType:
-            // we ignore fAlpahType, though some would not make sense
-            *isOpaque = true;
             return SkBitmap::kRGB_565_Config;
 
         case SkImage::kPMColor_ColorType:
-            switch (info.fAlphaType) {
-                case kIgnore_SkAlphaType:
-                case kUnpremul_SkAlphaType:
-                    // not supported yet
-                    return SkBitmap::kNo_Config;
-                case kOpaque_SkAlphaType:
-                    *isOpaque = true;
-                    return SkBitmap::kARGB_8888_Config;
-                case kPremul_SkAlphaType:
-                    *isOpaque = false;
-                    return SkBitmap::kARGB_8888_Config;
-            }
-            break;
+            return SkBitmap::kARGB_8888_Config;
 
         default:
             // break for unsupported colortypes
diff --git a/src/image/SkImagePriv.h b/src/image/SkImagePriv.h
index 2af8bbea92..5d93605566 100644
--- a/src/image/SkImagePriv.h
+++ b/src/image/SkImagePriv.h
@@ -13,8 +13,7 @@
 
 class SkPicture;
 
-extern SkBitmap::Config SkImageInfoToBitmapConfig(const SkImage::Info&,
-                                                  bool* isOpaque);
+extern SkBitmap::Config SkImageInfoToBitmapConfig(const SkImage::Info&);
 
 extern int SkImageBytesPerPixel(SkImage::ColorType);
 
diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp
index cd9b70f018..a208d83a7f 100644
--- a/src/image/SkImage_Raster.cpp
+++ b/src/image/SkImage_Raster.cpp
@@ -31,8 +31,7 @@ public:
             return false;
         }
 
-        bool isOpaque;
-        if (SkImageInfoToBitmapConfig(info, &isOpaque) == SkBitmap::kNo_Config) {
+        if (SkImageInfoToBitmapConfig(info) == SkBitmap::kNo_Config) {
             return false;
         }
 
@@ -85,23 +84,19 @@ SkImage* SkImage_Raster::NewEmpty() {
 
 SkImage_Raster::SkImage_Raster(const Info& info, SkData* data, size_t rowBytes)
         : INHERITED(info.fWidth, info.fHeight) {
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
 
-    fBitmap.setConfig(config, info.fWidth, info.fHeight, rowBytes);
+    fBitmap.setConfig(config, info.fWidth, info.fHeight, rowBytes, info.fAlphaType);
     fBitmap.setPixelRef(SkNEW_ARGS(SkDataPixelRef, (data)))->unref();
-    fBitmap.setIsOpaque(isOpaque);
     fBitmap.setImmutable();
 }
 
 SkImage_Raster::SkImage_Raster(const Info& info, SkPixelRef* pr, size_t rowBytes)
 : INHERITED(info.fWidth, info.fHeight) {
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
 
-    fBitmap.setConfig(config, info.fWidth, info.fHeight, rowBytes);
+    fBitmap.setConfig(config, info.fWidth, info.fHeight, rowBytes, info.fAlphaType);
     fBitmap.setPixelRef(pr);
-    fBitmap.setIsOpaque(isOpaque);
 }
 
 SkImage_Raster::~SkImage_Raster() {}
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index e5b7bd4486..7b3a6437d9 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -38,12 +38,11 @@ SK_DEFINE_INST_COUNT(SkSurface_Gpu)
 SkSurface_Gpu::SkSurface_Gpu(GrContext* ctx, const SkImage::Info& info,
                              int sampleCount)
         : INHERITED(info.fWidth, info.fHeight) {
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
 
     fDevice = SkNEW_ARGS(SkGpuDevice, (ctx, config, info.fWidth, info.fHeight, sampleCount));
 
-    if (!isOpaque) {
+    if (!SkAlphaTypeIsOpaque(info.fAlphaType)) {
         fDevice->clear(0x0);
     }
 }
@@ -119,8 +118,7 @@ SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, const SkImage::Info& info,
         return NULL;
     }
 
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
 
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit | kCheckAllocation_GrTextureFlagBit;
@@ -136,3 +134,4 @@ SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, const SkImage::Info& info,
 
     return SkNEW_ARGS(SkSurface_Gpu, (ctx, tex->asRenderTarget()));
 }
+
diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp
index ccfdd27b1c..5beabf71cc 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -39,8 +39,7 @@ private:
 bool SkSurface_Raster::Valid(const SkImage::Info& info, size_t rowBytes) {
     static const size_t kMaxTotalSize = SK_MaxS32;
 
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
 
     int shift = 0;
     switch (config) {
@@ -83,26 +82,20 @@ bool SkSurface_Raster::Valid(const SkImage::Info& info, size_t rowBytes) {
 
 SkSurface_Raster::SkSurface_Raster(const SkImage::Info& info, void* pixels, size_t rb)
         : INHERITED(info.fWidth, info.fHeight) {
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
-
-    fBitmap.setConfig(config, info.fWidth, info.fHeight, rb);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
+    fBitmap.setConfig(config, info.fWidth, info.fHeight, rb, info.fAlphaType);
     fBitmap.setPixels(pixels);
-    fBitmap.setIsOpaque(isOpaque);
     fWeOwnThePixels = false;    // We are "Direct"
 }
 
 SkSurface_Raster::SkSurface_Raster(const SkImage::Info& info, SkPixelRef* pr, size_t rb)
         : INHERITED(info.fWidth, info.fHeight) {
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
-
-    fBitmap.setConfig(config, info.fWidth, info.fHeight, rb);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
+    fBitmap.setConfig(config, info.fWidth, info.fHeight, rb, info.fAlphaType);
     fBitmap.setPixelRef(pr);
-    fBitmap.setIsOpaque(isOpaque);
     fWeOwnThePixels = true;
 
-    if (!isOpaque) {
+    if (!SkAlphaTypeIsOpaque(info.fAlphaType)) {
         fBitmap.eraseColor(SK_ColorTRANSPARENT);
     }
 }
diff --git a/src/images/SkImageDecoder.cpp b/src/images/SkImageDecoder.cpp
index 15cd1a60c0..3ee41124c0 100644
--- a/src/images/SkImageDecoder.cpp
+++ b/src/images/SkImageDecoder.cpp
@@ -245,8 +245,7 @@ bool SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
     }
     // if the destination has no pixels then we must allocate them.
     if (dst->isNull()) {
-        dst->setConfig(src->getConfig(), w, h);
-        dst->setIsOpaque(src->isOpaque());
+        dst->setConfig(src->getConfig(), w, h, 0, src->alphaType());
 
         if (!this->allocPixelRef(dst, NULL)) {
             SkDEBUGF(("failed to allocate pixels needed to crop the bitmap"));
diff --git a/src/images/SkImageDecoder_libbmp.cpp b/src/images/SkImageDecoder_libbmp.cpp
index 2283dbf51d..34a88ac6b0 100644
--- a/src/images/SkImageDecoder_libbmp.cpp
+++ b/src/images/SkImageDecoder_libbmp.cpp
@@ -133,8 +133,8 @@ bool SkBMPImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
 
     SkScaledBitmapSampler sampler(width, height, getSampleSize());
 
-    bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
-    bm->setIsOpaque(true);
+    bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0,
+                  kOpaque_SkAlphaType);
 
     if (justBounds) {
         return true;
diff --git a/src/images/SkImageDecoder_libjpeg.cpp b/src/images/SkImageDecoder_libjpeg.cpp
index 52c7483d7c..67b17823e2 100644
--- a/src/images/SkImageDecoder_libjpeg.cpp
+++ b/src/images/SkImageDecoder_libjpeg.cpp
@@ -543,9 +543,9 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
 #endif
 
     if (1 == sampleSize && SkImageDecoder::kDecodeBounds_Mode == mode) {
-        bm->setConfig(config, cinfo.image_width, cinfo.image_height);
-        bm->setIsOpaque(config != SkBitmap::kA8_Config);
-        return true;
+        return bm->setConfig(config, cinfo.image_width, cinfo.image_height, 0,
+                             SkBitmap::kA8_Config == config ?
+                                kPremul_SkAlphaType : kOpaque_SkAlphaType);
     }
 
     /*  image_width and image_height are the original dimensions, available
@@ -565,9 +565,9 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
         if (SkImageDecoder::kDecodeBounds_Mode == mode && valid_output_dimensions(cinfo)) {
             SkScaledBitmapSampler smpl(cinfo.output_width, cinfo.output_height,
                                        recompute_sampleSize(sampleSize, cinfo));
-            bm->setConfig(config, smpl.scaledWidth(), smpl.scaledHeight());
-            bm->setIsOpaque(config != SkBitmap::kA8_Config);
-            return true;
+            return bm->setConfig(config, smpl.scaledWidth(), smpl.scaledHeight(),
+                                 0, SkBitmap::kA8_Config == config ?
+                                    kPremul_SkAlphaType : kOpaque_SkAlphaType);
         } else {
             return return_false(cinfo, *bm, "start_decompress");
         }
@@ -580,8 +580,8 @@ bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     }
 
     SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, sampleSize);
-    bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
-    bm->setIsOpaque(config != SkBitmap::kA8_Config);
+    bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0,
+                  SkBitmap::kA8_Config != config ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
@@ -801,8 +801,8 @@ bool SkJPEGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) {
     SkScaledBitmapSampler sampler(width, height, skiaSampleSize);
 
     SkBitmap bitmap;
-    bitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
-    bitmap.setIsOpaque(true);
+    bitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0,
+                     kOpaque_SkAlphaType);
 
     // Check ahead of time if the swap(dest, src) is possible or not.
     // If yes, then we will stick to AllocPixelRef since it's cheaper with the
diff --git a/src/images/SkImageDecoder_libpng.cpp b/src/images/SkImageDecoder_libpng.cpp
index 5fc9350b51..e54387af34 100644
--- a/src/images/SkImageDecoder_libpng.cpp
+++ b/src/images/SkImageDecoder_libpng.cpp
@@ -466,7 +466,16 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap,
     if (SkBitmap::kA8_Config == decodedBitmap->config()) {
         reallyHasAlpha = true;
     }
-    decodedBitmap->setIsOpaque(!reallyHasAlpha);
+    
+    SkAlphaType alphaType = kOpaque_SkAlphaType;
+    if (reallyHasAlpha) {
+        if (this->getRequireUnpremultipliedColors()) {
+            alphaType = kUnpremul_SkAlphaType;
+        } else {
+            alphaType = kPremul_SkAlphaType;
+        }
+    }
+    decodedBitmap->setAlphaType(alphaType);
     return true;
 }
 
@@ -939,7 +948,15 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) {
     if (SkBitmap::kA8_Config == decodedBitmap.config()) {
         reallyHasAlpha = true;
     }
-    decodedBitmap.setIsOpaque(!reallyHasAlpha);
+    SkAlphaType alphaType = kOpaque_SkAlphaType;
+    if (reallyHasAlpha) {
+        if (this->getRequireUnpremultipliedColors()) {
+            alphaType = kUnpremul_SkAlphaType;
+        } else {
+            alphaType = kPremul_SkAlphaType;
+        }
+    }
+    decodedBitmap.setAlphaType(alphaType);
 
     if (swapOnly) {
         bm->swap(decodedBitmap);
diff --git a/src/images/SkImageDecoder_libwebp.cpp b/src/images/SkImageDecoder_libwebp.cpp
index 8bb716bae8..68014dd392 100644
--- a/src/images/SkImageDecoder_libwebp.cpp
+++ b/src/images/SkImageDecoder_libwebp.cpp
@@ -293,11 +293,8 @@ bool SkWEBPImageDecoder::setDecodeConfig(SkBitmap* decodedBitmap,
         return false;
     }
 
-    decodedBitmap->setConfig(config, width, height, 0);
-
-    decodedBitmap->setIsOpaque(!fHasAlpha);
-
-    return true;
+    return decodedBitmap->setConfig(config, width, height, 0,
+                                    fHasAlpha ? kPremul_SkAlphaType : kOpaque_SkAlphaType);
 }
 
 bool SkWEBPImageDecoder::onBuildTileIndex(SkStreamRewindable* stream,
diff --git a/src/images/SkImageDecoder_wbmp.cpp b/src/images/SkImageDecoder_wbmp.cpp
index 4a9944dbcd..8dce62cdf0 100644
--- a/src/images/SkImageDecoder_wbmp.cpp
+++ b/src/images/SkImageDecoder_wbmp.cpp
@@ -111,8 +111,8 @@ bool SkWBMPImageDecoder::onDecode(SkStream* stream, SkBitmap* decodedBitmap,
     int width = head.fWidth;
     int height = head.fHeight;
 
-    decodedBitmap->setConfig(SkBitmap::kIndex8_Config, width, height);
-    decodedBitmap->setIsOpaque(true);
+    decodedBitmap->setConfig(SkBitmap::kIndex8_Config, width, height, 0,
+                             kOpaque_SkAlphaType);
 
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
diff --git a/src/images/SkImageRef.cpp b/src/images/SkImageRef.cpp
index 9093b05156..ead835f7ab 100644
--- a/src/images/SkImageRef.cpp
+++ b/src/images/SkImageRef.cpp
@@ -64,7 +64,8 @@ bool SkImageRef::getInfo(SkBitmap* bitmap) {
 bool SkImageRef::isOpaque(SkBitmap* bitmap) {
     if (bitmap && bitmap->pixelRef() == this) {
         bitmap->lockPixels();
-        bitmap->setIsOpaque(fBitmap.isOpaque());
+        // what about colortables??????
+        bitmap->setAlphaType(fBitmap.alphaType());
         bitmap->unlockPixels();
         return true;
     }
diff --git a/src/lazy/SkBitmapFactory.cpp b/src/lazy/SkBitmapFactory.cpp
index 0ff4ee2d17..5464851402 100644
--- a/src/lazy/SkBitmapFactory.cpp
+++ b/src/lazy/SkBitmapFactory.cpp
@@ -53,16 +53,13 @@ bool SkBitmapFactory::installPixelRef(SkData* data, SkBitmap* dst) {
         return false;
     }
 
-    bool isOpaque = false;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
 
     Target target;
     // FIMXE: There will be a problem if this rowbytes is calculated differently from
     // in SkLazyPixelRef.
     target.fRowBytes = SkImageMinRowBytes(info);
-
-    dst->setConfig(config, info.fWidth, info.fHeight, target.fRowBytes);
-    dst->setIsOpaque(isOpaque);
+    dst->setConfig(config, info.fWidth, info.fHeight, target.fRowBytes, info.fAlphaType);
 
     // fImageCache and fCacheSelector are mutually exclusive.
     SkASSERT(NULL == fImageCache || NULL == fCacheSelector);
diff --git a/src/lazy/SkLazyPixelRef.cpp b/src/lazy/SkLazyPixelRef.cpp
index 9e023c4a7c..22d4b112f1 100644
--- a/src/lazy/SkLazyPixelRef.cpp
+++ b/src/lazy/SkLazyPixelRef.cpp
@@ -150,15 +150,14 @@ SkData* SkLazyPixelRef::onRefEncodedData() {
 
 static bool init_from_info(SkBitmap* bm, const SkImage::Info& info,
                            size_t rowBytes) {
-    bool isOpaque;
-    SkBitmap::Config config = SkImageInfoToBitmapConfig(info, &isOpaque);
+    SkBitmap::Config config = SkImageInfoToBitmapConfig(info);
     if (SkBitmap::kNo_Config == config) {
         return false;
     }
 
-    bm->setConfig(config, info.fWidth, info.fHeight, rowBytes);
-    bm->setIsOpaque(isOpaque);
-    return bm->allocPixels();
+    return bm->setConfig(config, info.fWidth, info.fHeight, rowBytes, info.fAlphaType)
+           &&
+           bm->allocPixels();
 }
 
 bool SkLazyPixelRef::onImplementsDecodeInto() {
diff --git a/src/ports/SkImageDecoder_CG.cpp b/src/ports/SkImageDecoder_CG.cpp
index 8956acaebc..3f850b544d 100644
--- a/src/ports/SkImageDecoder_CG.cpp
+++ b/src/ports/SkImageDecoder_CG.cpp
@@ -104,11 +104,13 @@ bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
         case kCGImageAlphaNoneSkipLast:
         case kCGImageAlphaNoneSkipFirst:
             SkASSERT(SkBitmap::ComputeIsOpaque(*bm));
-            bm->setIsOpaque(true);
+            bm->setAlphaType(kOpaque_SkAlphaType);
             break;
         default:
             // we don't know if we're opaque or not, so compute it.
-            bm->computeAndSetOpaquePredicate();
+            if (SkBitmap::ComputeIsOpaque(*bm)) {
+                bm->setAlphaType(kOpaque_SkAlphaType);
+            }
     }
     if (!bm->isOpaque() && this->getRequireUnpremultipliedColors()) {
         // CGBitmapContext does not support unpremultiplied, so the image has been premultiplied.
@@ -119,6 +121,7 @@ bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
                 *addr = unpremultiply_pmcolor(*addr);
             }
         }
+        bm->setAlphaType(kUnpremul_SkAlphaType);
     }
     bm->unlockPixels();
     return true;
diff --git a/src/ports/SkImageDecoder_WIC.cpp b/src/ports/SkImageDecoder_WIC.cpp
index c3666aca5c..1bda67fe91 100644
--- a/src/ports/SkImageDecoder_WIC.cpp
+++ b/src/ports/SkImageDecoder_WIC.cpp
@@ -240,7 +240,9 @@ bool SkImageDecoder_WIC::decodeStream(SkStream* stream, SkBitmap* bm, WICModes w
         );
 
         // Note: we don't need to premultiply here since we specified PBGRA
-        bm->computeAndSetOpaquePredicate();
+        if (ComputeIsOpaque(*bm)) {
+            bm->setAlphaType(kOpaque_SkAlphaType);
+        }
     }
 
     return SUCCEEDED(hr);
diff --git a/src/views/SkWindow.cpp b/src/views/SkWindow.cpp
index f25eb12379..d6fe32bd88 100644
--- a/src/views/SkWindow.cpp
+++ b/src/views/SkWindow.cpp
@@ -102,9 +102,8 @@ void SkWindow::resize(int width, int height, SkBitmap::Config config)
     if (width != fBitmap.width() || height != fBitmap.height() || config != fConfig)
     {
         fConfig = config;
-        fBitmap.setConfig(config, width, height);
+        fBitmap.setConfig(config, width, height, 0, kOpaque_SkAlphaType);
         fBitmap.allocPixels();
-        fBitmap.setIsOpaque(true);
 
         this->setSize(SkIntToScalar(width), SkIntToScalar(height));
         this->inval(NULL);
diff --git a/tests/ARGBImageEncoderTest.cpp b/tests/ARGBImageEncoderTest.cpp
index 9f68a0a151..bffcaa4f78 100644
--- a/tests/ARGBImageEncoderTest.cpp
+++ b/tests/ARGBImageEncoderTest.cpp
@@ -48,7 +48,7 @@ void BitmapTransformerTestClass::onRun(Reporter* reporter) {
         {
             bitmap.setConfig(configs[configIndex], kWidth, kHeight);
             REPORTER_ASSERT(reporter, bitmap.allocPixels());
-            bitmap.setIsOpaque(true);
+            bitmap.setAlphaType(kOpaque_SkAlphaType);
             bitmap.eraseColor(SK_ColorBLUE);
             // Change rows [0,1] from blue to [red,green].
             SkCanvas canvas(bitmap);
diff --git a/tests/BitmapCopyTest.cpp b/tests/BitmapCopyTest.cpp
index cccde8af92..bf0d2f7813 100644
--- a/tests/BitmapCopyTest.cpp
+++ b/tests/BitmapCopyTest.cpp
@@ -249,8 +249,8 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                 SkColorTable* ctOpaque = NULL;
                 SkColorTable* ctPremul = NULL;
 
-                srcOpaque.setConfig(gPairs[i].fConfig, W, H);
-                srcPremul.setConfig(gPairs[i].fConfig, W, H);
+                srcOpaque.setConfig(gPairs[i].fConfig, W, H, 0, kOpaque_SkAlphaType);
+                srcPremul.setConfig(gPairs[i].fConfig, W, H, 0, kPremul_SkAlphaType);
                 if (SkBitmap::kIndex8_Config == gPairs[i].fConfig) {
                     ctOpaque = init_ctable(kOpaque_SkAlphaType);
                     ctPremul = init_ctable(kPremul_SkAlphaType);
@@ -259,9 +259,6 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                 srcPremul.allocPixels(ctPremul);
                 SkSafeUnref(ctOpaque);
                 SkSafeUnref(ctPremul);
-
-                srcOpaque.setIsOpaque(true);
-                srcPremul.setIsOpaque(false);
             }
             init_src(srcOpaque);
             init_src(srcPremul);
@@ -315,7 +312,7 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                         REPORTER_ASSERT(reporter, subset.width() == 1);
                         REPORTER_ASSERT(reporter, subset.height() == 1);
                         REPORTER_ASSERT(reporter,
-                                        subset.isOpaque() == bitmap.isOpaque());
+                                        subset.alphaType() == bitmap.alphaType());
                         REPORTER_ASSERT(reporter,
                                         subset.isVolatile() == true);
 
@@ -333,12 +330,11 @@ static void TestBitmapCopy(skiatest::Reporter* reporter) {
                         REPORTER_ASSERT(reporter,
                                     (copy.getColorTable() != NULL) == hasCT);
                     }
-
                     bitmap = srcPremul;
                     bitmap.setIsVolatile(false);
                     if (bitmap.extractSubset(&subset, r)) {
                         REPORTER_ASSERT(reporter,
-                                        subset.isOpaque() == bitmap.isOpaque());
+                                        subset.alphaType() == bitmap.alphaType());
                         REPORTER_ASSERT(reporter,
                                         subset.isVolatile() == false);
                     }
diff --git a/tests/BitmapHasherTest.cpp b/tests/BitmapHasherTest.cpp
index 924cea2dcc..d6c9e6ab2f 100644
--- a/tests/BitmapHasherTest.cpp
+++ b/tests/BitmapHasherTest.cpp
@@ -31,7 +31,7 @@ namespace skiatest {
                               SkColor color) {
             bitmap.setConfig(config, width, height);
             REPORTER_ASSERT(fReporter, bitmap.allocPixels());
-            bitmap.setIsOpaque(true);
+            bitmap.setAlphaType(kOpaque_SkAlphaType);
             bitmap.eraseColor(color);
         }
 
diff --git a/tests/DeferredCanvasTest.cpp b/tests/DeferredCanvasTest.cpp
index e8075bd68f..537a810aa9 100644
--- a/tests/DeferredCanvasTest.cpp
+++ b/tests/DeferredCanvasTest.cpp
@@ -333,7 +333,7 @@ static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
         paint.setStyle(SkPaint::kFill_Style);
         SkBitmap bmp;
         create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
-        bmp.setIsOpaque(true);
+        bmp.setAlphaType(kOpaque_SkAlphaType);
         SkShader* shader = SkShader::CreateBitmapShader(bmp,
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
         paint.setShader(shader)->unref();
@@ -371,7 +371,7 @@ static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
         paint.setStyle(SkPaint::kFill_Style);
         SkBitmap bmp;
         create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
-        bmp.setIsOpaque(false);
+        bmp.setAlphaType(kPremul_SkAlphaType);
         SkShader* shader = SkShader::CreateBitmapShader(bmp,
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
         paint.setShader(shader)->unref();
diff --git a/tests/ShaderOpacityTest.cpp b/tests/ShaderOpacityTest.cpp
index 0af25d1ec2..c3dc888ba3 100644
--- a/tests/ShaderOpacityTest.cpp
+++ b/tests/ShaderOpacityTest.cpp
@@ -32,7 +32,7 @@ static void test_bitmap(skiatest::Reporter* reporter) {
     shader->unref();
 
     // test 3: explicitly opaque
-    bmp.setIsOpaque(true);
+    bmp.setAlphaType(kOpaque_SkAlphaType);
     shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
@@ -40,7 +40,7 @@ static void test_bitmap(skiatest::Reporter* reporter) {
     shader->unref();
 
     // test 4: explicitly not opaque
-    bmp.setIsOpaque(false);
+    bmp.setAlphaType(kPremul_SkAlphaType);
     shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);