diff --git a/src/core/SkAAClip.cpp b/src/core/SkAAClip.cpp
index 19e94c8..e55451e 100644
--- a/src/core/SkAAClip.cpp
+++ b/src/core/SkAAClip.cpp
@@ -1297,7 +1297,7 @@
     void blitMask(const SkMask&, const SkIRect& clip) override
         { unexpected(); }
 
-    const SkPixmap* justAnOpaqueColor(uint32_t*) override {
+    const SkBitmap* justAnOpaqueColor(uint32_t*) override {
         return NULL;
     }
 
@@ -2219,6 +2219,6 @@
     } while (y < stopY);
 }
 
-const SkPixmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkAAClipBlitter::justAnOpaqueColor(uint32_t* value) {
     return NULL;
 }
diff --git a/src/core/SkAAClip.h b/src/core/SkAAClip.h
index 9f6a3d6..1daeb38 100644
--- a/src/core/SkAAClip.h
+++ b/src/core/SkAAClip.h
@@ -110,11 +110,12 @@
     }
 
     void blitH(int x, int y, int width) override;
-    void blitAntiH(int x, int y, const SkAlpha[], const int16_t runs[]) override;
+    virtual void blitAntiH(int x, int y, const SkAlpha[],
+                           const int16_t runs[]) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
     void blitMask(const SkMask&, const SkIRect& clip) override;
-    const SkPixmap* justAnOpaqueColor(uint32_t* value) override;
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
 
 private:
     SkBlitter*      fBlitter;
diff --git a/src/core/SkBlitBWMaskTemplate.h b/src/core/SkBlitBWMaskTemplate.h
index accf498..798e44a 100644
--- a/src/core/SkBlitBWMaskTemplate.h
+++ b/src/core/SkBlitBWMaskTemplate.h
@@ -19,19 +19,19 @@
     SK_BLITBWMASK_NAME          name of function(const SkBitmap& bitmap, const SkMask& mask, const SkIRect& clip, SK_BLITBWMASK_ARGS)
     SK_BLITBWMASK_ARGS          list of additional arguments to SK_BLITBWMASK_NAME, beginning with a comma
     SK_BLITBWMASK_BLIT8         name of function(U8CPU byteMask, SK_BLITBWMASK_DEVTYPE* dst, int x, int y)
-    SK_BLITBWMASK_GETADDR       either writable_addr[8,16,32]
+    SK_BLITBWMASK_GETADDR       either getAddr32 or getAddr16 or getAddr8
     SK_BLITBWMASK_DEVTYPE       either U32 or U16 or U8
 */
 
-static void SK_BLITBWMASK_NAME(const SkPixmap& dst, const SkMask& srcMask,
-                               const SkIRect& clip SK_BLITBWMASK_ARGS) {
+static void SK_BLITBWMASK_NAME(const SkBitmap& bitmap, const SkMask& srcMask, const SkIRect& clip SK_BLITBWMASK_ARGS)
+{
     SkASSERT(clip.fRight <= srcMask.fBounds.fRight);
 
     int cx = clip.fLeft;
     int cy = clip.fTop;
     int maskLeft = srcMask.fBounds.fLeft;
     unsigned mask_rowBytes = srcMask.fRowBytes;
-    size_t bitmap_rowBytes = dst.rowBytes();
+    size_t bitmap_rowBytes = bitmap.rowBytes();
     unsigned height = clip.height();
 
     SkASSERT(mask_rowBytes != 0);
@@ -39,7 +39,7 @@
     SkASSERT(height != 0);
 
     const uint8_t* bits = srcMask.getAddr1(cx, cy);
-    SK_BLITBWMASK_DEVTYPE* device = dst.SK_BLITBWMASK_GETADDR(cx, cy);
+    SK_BLITBWMASK_DEVTYPE* device = bitmap.SK_BLITBWMASK_GETADDR(cx, cy);
 
     if (cx == maskLeft && clip.fRight == srcMask.fBounds.fRight)
     {
diff --git a/src/core/SkBlitMask.h b/src/core/SkBlitMask.h
index 3fc306f..32db43c 100644
--- a/src/core/SkBlitMask.h
+++ b/src/core/SkBlitMask.h
@@ -8,9 +8,9 @@
 #ifndef SkBlitMask_DEFINED
 #define SkBlitMask_DEFINED
 
+#include "SkBitmap.h"
 #include "SkColor.h"
 #include "SkMask.h"
-#include "SkPixmap.h"
 
 class SkBlitMask {
 public:
@@ -18,7 +18,7 @@
      *  Returns true if the device config and mask format were supported.
      *  else return false (nothing was drawn)
      */
-    static bool BlitColor(const SkPixmap& device, const SkMask& mask,
+    static bool BlitColor(const SkBitmap& device, const SkMask& mask,
                           const SkIRect& clip, SkColor color);
 
     /**
diff --git a/src/core/SkBlitMask_D32.cpp b/src/core/SkBlitMask_D32.cpp
index 2108108..594a274 100644
--- a/src/core/SkBlitMask_D32.cpp
+++ b/src/core/SkBlitMask_D32.cpp
@@ -147,13 +147,13 @@
     return NULL;
 }
 
-bool SkBlitMask::BlitColor(const SkPixmap& device, const SkMask& mask,
+bool SkBlitMask::BlitColor(const SkBitmap& device, const SkMask& mask,
                            const SkIRect& clip, SkColor color) {
     ColorProc proc = ColorFactory(device.colorType(), mask.fFormat, color);
     if (proc) {
         int x = clip.fLeft;
         int y = clip.fTop;
-        proc(device.writable_addr32(x, y), device.rowBytes(), mask.getAddr(x, y),
+        proc(device.getAddr32(x, y), device.rowBytes(), mask.getAddr(x, y),
              mask.fRowBytes, color, clip.width(), clip.height());
         return true;
     }
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index 59078d6..2ac7b51 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -33,7 +33,7 @@
     return NULL;
 }
 
-const SkPixmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
     return NULL;
 }
 
@@ -243,7 +243,7 @@
 
 void SkNullBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {}
 
-const SkPixmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkNullBlitter::justAnOpaqueColor(uint32_t* value) {
     return NULL;
 }
 
@@ -404,7 +404,7 @@
     }
 }
 
-const SkPixmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
     return fBlitter->justAnOpaqueColor(value);
 }
 
@@ -540,7 +540,7 @@
     }
 }
 
-const SkPixmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
     return fBlitter->justAnOpaqueColor(value);
 }
 
@@ -778,7 +778,7 @@
 
 #include "SkCoreBlitters.h"
 
-SkBlitter* SkBlitter::Choose(const SkPixmap& device,
+SkBlitter* SkBlitter::Choose(const SkBitmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
                              SkTBlitterAllocator* allocator,
@@ -944,7 +944,7 @@
     typedef SkShader::Context INHERITED;
 };
 
-SkShaderBlitter::SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
+SkShaderBlitter::SkShaderBlitter(const SkBitmap& device, const SkPaint& paint,
                                  SkShader::Context* shaderContext)
         : INHERITED(device)
         , fShader(paint.getShader())
diff --git a/src/core/SkBlitter.h b/src/core/SkBlitter.h
index b8126c2..695585a 100644
--- a/src/core/SkBlitter.h
+++ b/src/core/SkBlitter.h
@@ -8,11 +8,11 @@
 #ifndef SkBlitter_DEFINED
 #define SkBlitter_DEFINED
 
+#include "SkBitmap.h"
 #include "SkBitmapProcShader.h"
 #include "SkMask.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
-#include "SkPixmap.h"
 #include "SkRefCnt.h"
 #include "SkRegion.h"
 #include "SkShader.h"
@@ -51,7 +51,7 @@
         bitmap it draws into, and assign value. If not, return NULL and ignore
         the value parameter.
     */
-    virtual const SkPixmap* justAnOpaqueColor(uint32_t* value);
+    virtual const SkBitmap* justAnOpaqueColor(uint32_t* value);
 
     // (x, y), (x + 1, y)
     virtual void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
@@ -122,7 +122,7 @@
     /** @name Factories
         Return the correct blitter to use given the specified context.
      */
-    static SkBlitter* Choose(const SkPixmap& dst,
+    static SkBlitter* Choose(const SkBitmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& paint,
                              SkTBlitterAllocator*,
@@ -152,7 +152,7 @@
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
     void blitMask(const SkMask&, const SkIRect& clip) override;
-    const SkPixmap* justAnOpaqueColor(uint32_t* value) override;
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
     bool isNullBlitter() const override;
 };
 
@@ -176,7 +176,7 @@
     virtual void blitAntiRect(int x, int y, int width, int height,
                      SkAlpha leftAlpha, SkAlpha rightAlpha) override;
     void blitMask(const SkMask&, const SkIRect& clip) override;
-    const SkPixmap* justAnOpaqueColor(uint32_t* value) override;
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
 
     int requestRowsPreserved() const override {
         return fBlitter->requestRowsPreserved();
@@ -211,7 +211,7 @@
     virtual void blitAntiRect(int x, int y, int width, int height,
                      SkAlpha leftAlpha, SkAlpha rightAlpha) override;
     void blitMask(const SkMask&, const SkIRect& clip) override;
-    const SkPixmap* justAnOpaqueColor(uint32_t* value) override;
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) override;
 
     int requestRowsPreserved() const override {
         return fBlitter->requestRowsPreserved();
diff --git a/src/core/SkBlitter_A8.cpp b/src/core/SkBlitter_A8.cpp
index ce7d6e7..11f4259 100644
--- a/src/core/SkBlitter_A8.cpp
+++ b/src/core/SkBlitter_A8.cpp
@@ -12,11 +12,12 @@
 #include "SkShader.h"
 #include "SkXfermode.h"
 
-SkA8_Blitter::SkA8_Blitter(const SkPixmap& device, const SkPaint& paint) : INHERITED(device) {
+SkA8_Blitter::SkA8_Blitter(const SkBitmap& device, const SkPaint& paint)
+        : INHERITED(device) {
     fSrcA = paint.getAlpha();
 }
 
-const SkPixmap* SkA8_Blitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkA8_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (255 == fSrcA) {
         *value = 255;
         return &fDevice;
@@ -32,7 +33,7 @@
         return;
     }
 
-    uint8_t* device = fDevice.writable_addr8(x, y);
+    uint8_t* device = fDevice.getAddr8(x, y);
 
     if (fSrcA == 255) {
         memset(device, 0xFF, width);
@@ -52,7 +53,7 @@
         return;
     }
 
-    uint8_t*    device = fDevice.writable_addr8(x, y);
+    uint8_t*    device = fDevice.getAddr8(x, y);
     unsigned    srcA = fSrcA;
 
     for (;;) {
@@ -96,7 +97,7 @@
 #define SK_BLITBWMASK_NAME                  SkA8_BlitBW
 #define SK_BLITBWMASK_ARGS
 #define SK_BLITBWMASK_BLIT8(mask, dst)      solid_8_pixels(mask, dst)
-#define SK_BLITBWMASK_GETADDR               writable_addr8
+#define SK_BLITBWMASK_GETADDR               getAddr8
 #define SK_BLITBWMASK_DEVTYPE               uint8_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -115,7 +116,7 @@
 #define SK_BLITBWMASK_NAME                  SkA8_BlendBW
 #define SK_BLITBWMASK_ARGS                  , U8CPU sa, unsigned dst_scale
 #define SK_BLITBWMASK_BLIT8(mask, dst)      blend_8_pixels(mask, dst, sa, dst_scale)
-#define SK_BLITBWMASK_GETADDR               writable_addr8
+#define SK_BLITBWMASK_GETADDR               getAddr8
 #define SK_BLITBWMASK_DEVTYPE               uint8_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -138,7 +139,7 @@
     int y = clip.fTop;
     int width = clip.width();
     int height = clip.height();
-    uint8_t* device = fDevice.writable_addr8(x, y);
+    uint8_t* device = fDevice.getAddr8(x, y);
     const uint8_t* alpha = mask.getAddr8(x, y);
     unsigned    srcA = fSrcA;
 
@@ -178,7 +179,7 @@
     }
 
     unsigned sa = SkAlphaMul(fSrcA, SkAlpha255To256(alpha));
-    uint8_t* device = fDevice.writable_addr8(x, y);
+    uint8_t* device = fDevice.getAddr8(x, y);
     size_t   rowBytes = fDevice.rowBytes();
 
     if (sa == 0xFF) {
@@ -205,7 +206,7 @@
         return;
     }
 
-    uint8_t*    device = fDevice.writable_addr8(x, y);
+    uint8_t*    device = fDevice.getAddr8(x, y);
     unsigned    srcA = fSrcA;
 
     if (srcA == 255) {
@@ -227,10 +228,9 @@
 
 ///////////////////////////////////////////////////////////////////////
 
-SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
+SkA8_Shader_Blitter::SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
                                          SkShader::Context* shaderContext)
-    : INHERITED(device, paint, shaderContext)
-{
+    : INHERITED(device, paint, shaderContext) {
     if ((fXfermode = paint.getXfermode()) != NULL) {
         fXfermode->ref();
         SkASSERT(fShaderContext);
@@ -250,7 +250,7 @@
     SkASSERT(x >= 0 && y >= 0 &&
              (unsigned)(x + width) <= (unsigned)fDevice.width());
 
-    uint8_t* device = fDevice.writable_addr8(x, y);
+    uint8_t* device = fDevice.getAddr8(x, y);
     SkShader::Context* shaderContext = fShaderContext;
 
     if ((shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag) && !fXfermode) {
@@ -288,7 +288,7 @@
     SkXfermode*        mode = fXfermode;
     uint8_t*           aaExpand = fAAExpand;
     SkPMColor*         span = fBuffer;
-    uint8_t*           device = fDevice.writable_addr8(x, y);
+    uint8_t*           device = fDevice.getAddr8(x, y);
     int                opaque = shaderContext->getFlags() & SkShader::kOpaqueAlpha_Flag;
 
     for (;;) {
@@ -329,7 +329,7 @@
     int y = clip.fTop;
     int width = clip.width();
     int height = clip.height();
-    uint8_t* device = fDevice.writable_addr8(x, y);
+    uint8_t* device = fDevice.getAddr8(x, y);
     const uint8_t* alpha = mask.getAddr8(x, y);
     SkShader::Context* shaderContext = fShaderContext;
 
@@ -353,7 +353,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkPixmap& device,
+SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkBitmap& device,
                              const SkPaint& paint) : SkRasterBlitter(device) {
     SkASSERT(NULL == paint.getShader());
     SkASSERT(NULL == paint.getXfermode());
@@ -362,7 +362,7 @@
 
 void SkA8_Coverage_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                       const int16_t runs[]) {
-    uint8_t* device = fDevice.writable_addr8(x, y);
+    uint8_t* device = fDevice.getAddr8(x, y);
     SkDEBUGCODE(int totalCount = 0;)
 
     for (;;) {
@@ -384,7 +384,7 @@
 }
 
 void SkA8_Coverage_Blitter::blitH(int x, int y, int width) {
-    memset(fDevice.writable_addr8(x, y), 0xFF, width);
+    memset(fDevice.getAddr8(x, y), 0xFF, width);
 }
 
 void SkA8_Coverage_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
@@ -392,7 +392,7 @@
         return;
     }
 
-    uint8_t* dst = fDevice.writable_addr8(x, y);
+    uint8_t* dst = fDevice.getAddr8(x, y);
     const size_t dstRB = fDevice.rowBytes();
     while (--height >= 0) {
         *dst = alpha;
@@ -401,7 +401,7 @@
 }
 
 void SkA8_Coverage_Blitter::blitRect(int x, int y, int width, int height) {
-    uint8_t* dst = fDevice.writable_addr8(x, y);
+    uint8_t* dst = fDevice.getAddr8(x, y);
     const size_t dstRB = fDevice.rowBytes();
     while (--height >= 0) {
         memset(dst, 0xFF, width);
@@ -417,7 +417,7 @@
     int width = clip.width();
     int height = clip.height();
 
-    uint8_t* dst = fDevice.writable_addr8(x, y);
+    uint8_t* dst = fDevice.getAddr8(x, y);
     const uint8_t* src = mask.getAddr8(x, y);
     const size_t srcRB = mask.fRowBytes;
     const size_t dstRB = fDevice.rowBytes();
@@ -429,6 +429,6 @@
     }
 }
 
-const SkPixmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) {
+const SkBitmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) {
     return NULL;
 }
diff --git a/src/core/SkBlitter_ARGB32.cpp b/src/core/SkBlitter_ARGB32.cpp
index 683acf0..f2de82a 100644
--- a/src/core/SkBlitter_ARGB32.cpp
+++ b/src/core/SkBlitter_ARGB32.cpp
@@ -14,7 +14,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void SkARGB32_Blit32(const SkPixmap& device, const SkMask& mask,
+static void SkARGB32_Blit32(const SkBitmap& device, const SkMask& mask,
                             const SkIRect& clip, SkPMColor srcColor) {
     U8CPU alpha = SkGetPackedA32(srcColor);
     unsigned flags = SkBlitRow::kSrcPixelAlpha_Flag32;
@@ -28,7 +28,7 @@
     int width = clip.width();
     int height = clip.height();
 
-    SkPMColor* dstRow = device.writable_addr32(x, y);
+    SkPMColor*         dstRow = device.getAddr32(x, y);
     const SkPMColor* srcRow = reinterpret_cast<const SkPMColor*>(mask.getAddr8(x, y));
 
     do {
@@ -40,7 +40,7 @@
 
 //////////////////////////////////////////////////////////////////////////////////////
 
-SkARGB32_Blitter::SkARGB32_Blitter(const SkPixmap& device, const SkPaint& paint)
+SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
         : INHERITED(device) {
     SkColor color = paint.getColor();
     fColor = color;
@@ -54,7 +54,7 @@
     fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
 }
 
-const SkPixmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (255 == fSrcA) {
         *value = fPMColor;
         return &fDevice;
@@ -70,7 +70,7 @@
 void SkARGB32_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
 
-    uint32_t* device = fDevice.writable_addr32(x, y);
+    uint32_t*   device = fDevice.getAddr32(x, y);
     SkBlitRow::Color32(device, device, width, fPMColor);
 }
 
@@ -81,7 +81,7 @@
     }
 
     uint32_t    color = fPMColor;
-    uint32_t*   device = fDevice.writable_addr32(x, y);
+    uint32_t*   device = fDevice.getAddr32(x, y);
     unsigned    opaqueMask = fSrcA; // if fSrcA is 0xFF, then we will catch the fast opaque case
 
     for (;;) {
@@ -106,16 +106,16 @@
 }
 
 void SkARGB32_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
-    uint32_t* device = fDevice.writable_addr32(x, y);
-    SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
+    uint32_t* device = fDevice.getAddr32(x, y);
+    SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);)
 
     device[0] = SkBlendARGB32(fPMColor, device[0], a0);
     device[1] = SkBlendARGB32(fPMColor, device[1], a1);
 }
 
 void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
-    uint32_t* device = fDevice.writable_addr32(x, y);
-    SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
+    uint32_t* device = fDevice.getAddr32(x, y);
+    SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
 
     device[0] = SkBlendARGB32(fPMColor, device[0], a0);
     device = (uint32_t*)((char*)device + fDevice.rowBytes());
@@ -139,7 +139,7 @@
 #define SK_BLITBWMASK_NAME                  SkARGB32_BlitBW
 #define SK_BLITBWMASK_ARGS                  , SkPMColor color
 #define SK_BLITBWMASK_BLIT8(mask, dst)      solid_8_pixels(mask, dst, color)
-#define SK_BLITBWMASK_GETADDR               writable_addr32
+#define SK_BLITBWMASK_GETADDR               getAddr32
 #define SK_BLITBWMASK_DEVTYPE               uint32_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -158,7 +158,7 @@
 #define SK_BLITBWMASK_NAME                  SkARGB32_BlendBW
 #define SK_BLITBWMASK_ARGS                  , uint32_t sc, unsigned dst_scale
 #define SK_BLITBWMASK_BLIT8(mask, dst)      blend_8_pixels(mask, dst, sc, dst_scale)
-#define SK_BLITBWMASK_GETADDR               writable_addr32
+#define SK_BLITBWMASK_GETADDR               getAddr32
 #define SK_BLITBWMASK_DEVTYPE               uint32_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -197,16 +197,16 @@
 }
 
 void SkARGB32_Opaque_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
-    uint32_t* device = fDevice.writable_addr32(x, y);
-    SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
+    uint32_t* device = fDevice.getAddr32(x, y);
+    SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);)
 
     device[0] = SkFastFourByteInterp(fPMColor, device[0], a0);
     device[1] = SkFastFourByteInterp(fPMColor, device[1], a1);
 }
 
 void SkARGB32_Opaque_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
-    uint32_t* device = fDevice.writable_addr32(x, y);
-    SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
+    uint32_t* device = fDevice.getAddr32(x, y);
+    SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
 
     device[0] = SkFastFourByteInterp(fPMColor, device[0], a0);
     device = (uint32_t*)((char*)device + fDevice.rowBytes());
@@ -220,7 +220,7 @@
         return;
     }
 
-    uint32_t* device = fDevice.writable_addr32(x, y);
+    uint32_t* device = fDevice.getAddr32(x, y);
     uint32_t  color = fPMColor;
 
     if (alpha != 255) {
@@ -242,7 +242,7 @@
         return;
     }
 
-    uint32_t*   device = fDevice.writable_addr32(x, y);
+    uint32_t*   device = fDevice.getAddr32(x, y);
     uint32_t    color = fPMColor;
     size_t      rowBytes = fDevice.rowBytes();
 
@@ -260,7 +260,7 @@
 
 void SkARGB32_Black_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                        const int16_t runs[]) {
-    uint32_t*   device = fDevice.writable_addr32(x, y);
+    uint32_t*   device = fDevice.getAddr32(x, y);
     SkPMColor   black = (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT);
 
     for (;;) {
@@ -290,16 +290,16 @@
 }
 
 void SkARGB32_Black_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
-    uint32_t* device = fDevice.writable_addr32(x, y);
-    SkDEBUGCODE((void)fDevice.writable_addr32(x + 1, y);)
+    uint32_t* device = fDevice.getAddr32(x, y);
+    SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);)
 
     device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
     device[1] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[1], 256 - a1);
 }
 
 void SkARGB32_Black_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
-    uint32_t* device = fDevice.writable_addr32(x, y);
-    SkDEBUGCODE((void)fDevice.writable_addr32(x, y + 1);)
+    uint32_t* device = fDevice.getAddr32(x, y);
+    SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
 
     device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
     device = (uint32_t*)((char*)device + fDevice.rowBytes());
@@ -319,7 +319,7 @@
     }
 }
 
-SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkPixmap& device,
+SkARGB32_Shader_Blitter::SkARGB32_Shader_Blitter(const SkBitmap& device,
         const SkPaint& paint, SkShader::Context* shaderContext)
     : INHERITED(device, paint, shaderContext)
 {
@@ -363,7 +363,7 @@
 void SkARGB32_Shader_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
 
-    uint32_t* device = fDevice.writable_addr32(x, y);
+    uint32_t*   device = fDevice.getAddr32(x, y);
 
     if (fShadeDirectlyIntoDevice) {
         fShaderContext->shadeSpan(x, y, device, width);
@@ -382,7 +382,7 @@
     SkASSERT(x >= 0 && y >= 0 &&
              x + width <= fDevice.width() && y + height <= fDevice.height());
 
-    uint32_t*          device = fDevice.writable_addr32(x, y);
+    uint32_t*          device = fDevice.getAddr32(x, y);
     size_t             deviceRB = fDevice.rowBytes();
     SkShader::Context* shaderContext = fShaderContext;
     SkPMColor*         span = fBuffer;
@@ -457,7 +457,7 @@
 void SkARGB32_Shader_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                         const int16_t runs[]) {
     SkPMColor*         span = fBuffer;
-    uint32_t*          device = fDevice.writable_addr32(x, y);
+    uint32_t*          device = fDevice.getAddr32(x, y);
     SkShader::Context* shaderContext = fShaderContext;
 
     if (fXfermode && !fShadeDirectlyIntoDevice) {
@@ -558,7 +558,7 @@
     int y = clip.fTop;
     int height = clip.height();
 
-    char* dstRow = (char*)fDevice.writable_addr32(x, y);
+    char* dstRow = (char*)fDevice.getAddr32(x, y);
     const size_t dstRB = fDevice.rowBytes();
     const uint8_t* maskRow = (const uint8_t*)mask.getAddr(x, y);
     const size_t maskRB = mask.fRowBytes;
@@ -589,7 +589,7 @@
 void SkARGB32_Shader_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
     SkASSERT(x >= 0 && y >= 0 && y + height <= fDevice.height());
 
-    uint32_t*          device = fDevice.writable_addr32(x, y);
+    uint32_t*          device = fDevice.getAddr32(x, y);
     size_t             deviceRB = fDevice.rowBytes();
     SkShader::Context* shaderContext = fShaderContext;
 
diff --git a/src/core/SkBlitter_RGB16.cpp b/src/core/SkBlitter_RGB16.cpp
index 6724b12..ed9e103 100644
--- a/src/core/SkBlitter_RGB16.cpp
+++ b/src/core/SkBlitter_RGB16.cpp
@@ -1,3 +1,4 @@
+
 /*
  * Copyright 2006 The Android Open Source Project
  *
@@ -5,6 +6,7 @@
  * found in the LICENSE file.
  */
 
+
 #include "SkBlitRow.h"
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
@@ -56,14 +58,15 @@
 
 class SkRGB16_Blitter : public SkRasterBlitter {
 public:
-    SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint);
+    SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint);
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
-    void blitMask(const SkMask&, const SkIRect&) override;
-    const SkPixmap* justAnOpaqueColor(uint32_t*) override;
+    virtual void blitMask(const SkMask&,
+                          const SkIRect&) override;
+    const SkBitmap* justAnOpaqueColor(uint32_t*) override;
 
 protected:
     SkPMColor   fSrcColor32;
@@ -84,12 +87,14 @@
 
 class SkRGB16_Opaque_Blitter : public SkRGB16_Blitter {
 public:
-    SkRGB16_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint);
+    SkRGB16_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint);
     void blitH(int x, int y, int width) override;
-    void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override;
+    virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
+                           const int16_t* runs) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
-    void blitMask(const SkMask&, const SkIRect&) override;
+    virtual void blitMask(const SkMask&,
+                          const SkIRect&) override;
 
 private:
     typedef SkRGB16_Blitter INHERITED;
@@ -98,9 +103,10 @@
 #ifdef USE_BLACK_BLITTER
 class SkRGB16_Black_Blitter : public SkRGB16_Opaque_Blitter {
 public:
-    SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint);
+    SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint);
     void blitMask(const SkMask&, const SkIRect&) override;
-    void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override;
+    virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
+                           const int16_t* runs) override;
 
 private:
     typedef SkRGB16_Opaque_Blitter INHERITED;
@@ -109,7 +115,7 @@
 
 class SkRGB16_Shader_Blitter : public SkShaderBlitter {
 public:
-    SkRGB16_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
+    SkRGB16_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
                            SkShader::Context* shaderContext);
     virtual ~SkRGB16_Shader_Blitter();
     void blitH(int x, int y, int width) override;
@@ -132,7 +138,7 @@
 // used only if the shader can perform shadSpan16
 class SkRGB16_Shader16_Blitter : public SkRGB16_Shader_Blitter {
 public:
-    SkRGB16_Shader16_Blitter(const SkPixmap& device, const SkPaint& paint,
+    SkRGB16_Shader16_Blitter(const SkBitmap& device, const SkPaint& paint,
                              SkShader::Context* shaderContext);
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
@@ -145,7 +151,7 @@
 
 class SkRGB16_Shader_Xfermode_Blitter : public SkShaderBlitter {
 public:
-    SkRGB16_Shader_Xfermode_Blitter(const SkPixmap& device, const SkPaint& paint,
+    SkRGB16_Shader_Xfermode_Blitter(const SkBitmap& device, const SkPaint& paint,
                                     SkShader::Context* shaderContext);
     virtual ~SkRGB16_Shader_Xfermode_Blitter();
     void blitH(int x, int y, int width) override;
@@ -165,7 +171,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 #ifdef USE_BLACK_BLITTER
-SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint)
+SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint)
     : INHERITED(device, paint) {
     SkASSERT(paint.getShader() == NULL);
     SkASSERT(paint.getColorFilter() == NULL);
@@ -202,7 +208,7 @@
 #define SK_BLITBWMASK_NAME                  SkRGB16_Black_BlitBW
 #define SK_BLITBWMASK_ARGS
 #define SK_BLITBWMASK_BLIT8(mask, dst)      black_8_pixels(mask, dst)
-#define SK_BLITBWMASK_GETADDR               writable_addr16
+#define SK_BLITBWMASK_GETADDR               getAddr16
 #define SK_BLITBWMASK_DEVTYPE               uint16_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -211,7 +217,7 @@
     if (mask.fFormat == SkMask::kBW_Format) {
         SkRGB16_Black_BlitBW(fDevice, mask, clip);
     } else {
-        uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop);
+        uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop);
         const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop);
         unsigned width = clip.width();
         unsigned height = clip.height();
@@ -239,7 +245,7 @@
 void SkRGB16_Black_Blitter::blitAntiH(int x, int y,
                                       const SkAlpha* SK_RESTRICT antialias,
                                       const int16_t* SK_RESTRICT runs) {
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
 
     for (;;) {
         int count = runs[0];
@@ -271,13 +277,14 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Opaque_Blitter::SkRGB16_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint)
-    : INHERITED(device, paint) {}
+SkRGB16_Opaque_Blitter::SkRGB16_Opaque_Blitter(const SkBitmap& device,
+                                               const SkPaint& paint)
+: INHERITED(device, paint) {}
 
 void SkRGB16_Opaque_Blitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     SkASSERT(x + width <= fDevice.width());
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     uint16_t srcColor = fColor16;
 
     SkASSERT(fRawColor16 == srcColor);
@@ -300,7 +307,7 @@
 void SkRGB16_Opaque_Blitter::blitAntiH(int x, int y,
                                        const SkAlpha* SK_RESTRICT antialias,
                                        const int16_t* SK_RESTRICT runs) {
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     uint16_t    srcColor = fRawColor16;
     uint32_t    srcExpanded = fExpandedRaw16;
     int         ditherInt = Bool2Int(fDoDither);
@@ -365,7 +372,7 @@
 #define SK_BLITBWMASK_NAME                  SkRGB16_BlitBW
 #define SK_BLITBWMASK_ARGS                  , uint16_t color
 #define SK_BLITBWMASK_BLIT8(mask, dst)      solid_8_pixels(mask, dst, color)
-#define SK_BLITBWMASK_GETADDR               writable_addr16
+#define SK_BLITBWMASK_GETADDR               getAddr16
 #define SK_BLITBWMASK_DEVTYPE               uint16_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -382,7 +389,7 @@
         return;
     }
 
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop);
     const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop);
     int width = clip.width();
     int height = clip.height();
@@ -477,7 +484,7 @@
 }
 
 void SkRGB16_Opaque_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
 
     // TODO: respect fDoDither
@@ -493,7 +500,7 @@
 
 void SkRGB16_Opaque_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height());
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     size_t      deviceRB = fDevice.rowBytes();
     uint16_t    color16 = fColor16;
 
@@ -517,7 +524,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Blitter::SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint)
+SkRGB16_Blitter::SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint)
     : INHERITED(device) {
     SkColor color = paint.getColor();
 
@@ -554,7 +561,7 @@
     fColorProc16 = SkBlitRow::ColorFactory16(flags);
 }
 
-const SkPixmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (!fDoDither && 256 == fScale) {
         *value = fRawColor16;
         return &fDevice;
@@ -565,7 +572,7 @@
 void SkRGB16_Blitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     SkASSERT(x + width <= fDevice.width());
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
 
     fColorProc16(device, fSrcColor32, width, x, y);
 }
@@ -573,7 +580,7 @@
 void SkRGB16_Blitter::blitAntiH(int x, int y,
                                 const SkAlpha* SK_RESTRICT antialias,
                                 const int16_t* SK_RESTRICT runs) {
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     uint32_t    srcExpanded = fExpandedRaw16;
     unsigned    scale = fScale;
 
@@ -617,7 +624,7 @@
 #define SK_BLITBWMASK_NAME                  SkRGB16_BlendBW
 #define SK_BLITBWMASK_ARGS                  , unsigned dst_scale, U16CPU src_color
 #define SK_BLITBWMASK_BLIT8(mask, dst)      blend_8_pixels(mask, dst, dst_scale, src_color)
-#define SK_BLITBWMASK_GETADDR               writable_addr16
+#define SK_BLITBWMASK_GETADDR               getAddr16
 #define SK_BLITBWMASK_DEVTYPE               uint16_t
 #include "SkBlitBWMaskTemplate.h"
 
@@ -628,7 +635,7 @@
         return;
     }
 
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop);
     const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop);
     int width = clip.width();
     int height = clip.height();
@@ -652,7 +659,7 @@
 }
 
 void SkRGB16_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
 
     // TODO: respect fDoDither
@@ -668,7 +675,7 @@
 
 void SkRGB16_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height());
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
 
     while (--height >= 0) {
@@ -679,18 +686,17 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkPixmap& device,
+SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkBitmap& device,
                                                    const SkPaint& paint,
                                                    SkShader::Context* shaderContext)
-    : SkRGB16_Shader_Blitter(device, paint, shaderContext)
-{
+    : SkRGB16_Shader_Blitter(device, paint, shaderContext) {
     SkASSERT(SkShader::CanCallShadeSpan16(fShaderFlags));
 }
 
 void SkRGB16_Shader16_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
-    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
     SkShader::Context*    shaderContext = fShaderContext;
 
     int alpha = shaderContext->getSpan16Alpha();
@@ -705,7 +711,7 @@
 
 void SkRGB16_Shader16_Blitter::blitRect(int x, int y, int width, int height) {
     SkShader::Context* shaderContext = fShaderContext;
-    uint16_t*          dst = fDevice.writable_addr16(x, y);
+    uint16_t*          dst = fDevice.getAddr16(x, y);
     size_t             dstRB = fDevice.rowBytes();
     int                alpha = shaderContext->getSpan16Alpha();
 
@@ -753,7 +759,7 @@
                                          const int16_t* SK_RESTRICT runs) {
     SkShader::Context*     shaderContext = fShaderContext;
     SkPMColor* SK_RESTRICT span = fBuffer;
-    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT  device = fDevice.getAddr16(x, y);
 
     int alpha = shaderContext->getSpan16Alpha();
     uint16_t* span16 = (uint16_t*)span;
@@ -804,11 +810,10 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device,
+SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkBitmap& device,
                                                const SkPaint& paint,
                                                SkShader::Context* shaderContext)
-    : INHERITED(device, paint, shaderContext)
-{
+: INHERITED(device, paint, shaderContext) {
     SkASSERT(paint.getXfermode() == NULL);
 
     fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * sizeof(SkPMColor));
@@ -840,14 +845,14 @@
 
     fShaderContext->shadeSpan(x, y, fBuffer, width);
     // shaders take care of global alpha, so we pass 0xFF (should be ignored)
-    fOpaqueProc(fDevice.writable_addr16(x, y), fBuffer, width, 0xFF, x, y);
+    fOpaqueProc(fDevice.getAddr16(x, y), fBuffer, width, 0xFF, x, y);
 }
 
 void SkRGB16_Shader_Blitter::blitRect(int x, int y, int width, int height) {
     SkShader::Context* shaderContext = fShaderContext;
     SkBlitRow::Proc16  proc = fOpaqueProc;
     SkPMColor*         buffer = fBuffer;
-    uint16_t*          dst = fDevice.writable_addr16(x, y);
+    uint16_t*          dst = fDevice.getAddr16(x, y);
     size_t             dstRB = fDevice.rowBytes();
 
     if (fShaderFlags & SkShader::kConstInY32_Flag) {
@@ -886,7 +891,7 @@
                                        const int16_t* SK_RESTRICT runs) {
     SkShader::Context*     shaderContext = fShaderContext;
     SkPMColor* SK_RESTRICT span = fBuffer;
-    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT  device = fDevice.getAddr16(x, y);
 
     for (;;) {
         int count = *runs;
@@ -932,10 +937,9 @@
 ///////////////////////////////////////////////////////////////////////
 
 SkRGB16_Shader_Xfermode_Blitter::SkRGB16_Shader_Xfermode_Blitter(
-                                const SkPixmap& device, const SkPaint& paint,
+                                const SkBitmap& device, const SkPaint& paint,
                                 SkShader::Context* shaderContext)
-    : INHERITED(device, paint, shaderContext)
-{
+: INHERITED(device, paint, shaderContext) {
     fXfermode = paint.getXfermode();
     SkASSERT(fXfermode);
     fXfermode->ref();
@@ -953,7 +957,7 @@
 void SkRGB16_Shader_Xfermode_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
-    uint16_t*   device = fDevice.writable_addr16(x, y);
+    uint16_t*   device = fDevice.getAddr16(x, y);
     SkPMColor*  span = fBuffer;
 
     fShaderContext->shadeSpan(x, y, span, width);
@@ -967,7 +971,7 @@
     SkXfermode*            mode = fXfermode;
     SkPMColor* SK_RESTRICT span = fBuffer;
     uint8_t* SK_RESTRICT   aaExpand = fAAExpand;
-    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
+    uint16_t* SK_RESTRICT  device = fDevice.getAddr16(x, y);
 
     for (;;) {
         int count = *runs;
@@ -1017,7 +1021,7 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
+SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device, const SkPaint& paint,
         SkShader::Context* shaderContext,
         SkTBlitterAllocator* allocator) {
     SkASSERT(allocator != NULL);
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 056a4e9..26b76df 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -271,9 +271,7 @@
             fClip   = &((SkRasterClip*)&rec->fClip)->forceGetBW();
             fRC     = &rec->fClip;
             fDevice = rec->fDevice;
-            if (!fDevice->accessPixels(&fDst)) {
-                fDst.reset(fDevice->imageInfo(), NULL, 0);
-            }
+            fBitmap = &fDevice->accessBitmap(true);
             fPaint  = rec->fPaint;
             SkDEBUGCODE(this->validate();)
 
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 31f3397..18821dc 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -16,10 +16,10 @@
 
 class SkRasterBlitter : public SkBlitter {
 public:
-    SkRasterBlitter(const SkPixmap& device) : fDevice(device) {}
+    SkRasterBlitter(const SkBitmap& device) : fDevice(device) {}
 
 protected:
-    const SkPixmap fDevice;
+    const SkBitmap& fDevice;
 
 private:
     typedef SkBlitter INHERITED;
@@ -32,7 +32,7 @@
       *  The blitter only ensures that the storage always holds a live object, but it may
       *  exchange that object.
       */
-    SkShaderBlitter(const SkPixmap& device, const SkPaint& paint,
+    SkShaderBlitter(const SkBitmap& device, const SkPaint& paint,
                     SkShader::Context* shaderContext);
     virtual ~SkShaderBlitter();
 
@@ -61,24 +61,24 @@
 
 class SkA8_Coverage_Blitter : public SkRasterBlitter {
 public:
-    SkA8_Coverage_Blitter(const SkPixmap& device, const SkPaint& paint);
+    SkA8_Coverage_Blitter(const SkBitmap& device, const SkPaint& paint);
     void blitH(int x, int y, int width) override;
     void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
     void blitMask(const SkMask&, const SkIRect&) override;
-    const SkPixmap* justAnOpaqueColor(uint32_t*) override;
+    const SkBitmap* justAnOpaqueColor(uint32_t*) override;
 };
 
 class SkA8_Blitter : public SkRasterBlitter {
 public:
-    SkA8_Blitter(const SkPixmap& device, const SkPaint& paint);
+    SkA8_Blitter(const SkBitmap& device, const SkPaint& paint);
     virtual void blitH(int x, int y, int width);
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
     virtual void blitV(int x, int y, int height, SkAlpha alpha);
     virtual void blitRect(int x, int y, int width, int height);
     virtual void blitMask(const SkMask&, const SkIRect&);
-    virtual const SkPixmap* justAnOpaqueColor(uint32_t*);
+    virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
 
 private:
     unsigned fSrcA;
@@ -91,7 +91,7 @@
 
 class SkA8_Shader_Blitter : public SkShaderBlitter {
 public:
-    SkA8_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
+    SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
                         SkShader::Context* shaderContext);
     virtual ~SkA8_Shader_Blitter();
     virtual void blitH(int x, int y, int width);
@@ -113,13 +113,13 @@
 
 class SkARGB32_Blitter : public SkRasterBlitter {
 public:
-    SkARGB32_Blitter(const SkPixmap& device, const SkPaint& paint);
+    SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint);
     virtual void blitH(int x, int y, int width);
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
     virtual void blitV(int x, int y, int height, SkAlpha alpha);
     virtual void blitRect(int x, int y, int width, int height);
     virtual void blitMask(const SkMask&, const SkIRect&);
-    virtual const SkPixmap* justAnOpaqueColor(uint32_t*);
+    virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
     void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override;
     void blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) override;
 
@@ -138,7 +138,7 @@
 
 class SkARGB32_Opaque_Blitter : public SkARGB32_Blitter {
 public:
-    SkARGB32_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint)
+    SkARGB32_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint)
         : INHERITED(device, paint) { SkASSERT(paint.getAlpha() == 0xFF); }
     virtual void blitMask(const SkMask&, const SkIRect&);
     void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override;
@@ -150,7 +150,7 @@
 
 class SkARGB32_Black_Blitter : public SkARGB32_Opaque_Blitter {
 public:
-    SkARGB32_Black_Blitter(const SkPixmap& device, const SkPaint& paint)
+    SkARGB32_Black_Blitter(const SkBitmap& device, const SkPaint& paint)
         : INHERITED(device, paint) {}
     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
     void blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) override;
@@ -162,7 +162,7 @@
 
 class SkARGB32_Shader_Blitter : public SkShaderBlitter {
 public:
-    SkARGB32_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
+    SkARGB32_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
                             SkShader::Context* shaderContext);
     virtual ~SkARGB32_Shader_Blitter();
     void blitH(int x, int y, int width) override;
@@ -200,7 +200,7 @@
     SkBlitter::Choose(...)
  */
 
-SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
+SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device, const SkPaint& paint,
                                 SkShader::Context* shaderContext,
                                 SkTBlitterAllocator* allocator);
 
diff --git a/src/core/SkDeviceLooper.cpp b/src/core/SkDeviceLooper.cpp
index 840a050..a8350cc 100644
--- a/src/core/SkDeviceLooper.cpp
+++ b/src/core/SkDeviceLooper.cpp
@@ -7,16 +7,17 @@
 
 #include "SkDeviceLooper.h"
 
-SkDeviceLooper::SkDeviceLooper(const SkPixmap& base, const SkRasterClip& rc, const SkIRect& bounds,
-                               bool aa)
-    : fBaseDst(base)
+SkDeviceLooper::SkDeviceLooper(const SkBitmap& base,
+                               const SkRasterClip& rc,
+                               const SkIRect& bounds, bool aa)
+    : fBaseBitmap(base)
     , fBaseRC(rc)
     , fSubsetRC(rc.isForceConservativeRects())
     , fDelta(aa ? kAA_Delta : kBW_Delta)
 {
     // sentinels that next() has not yet been called, and so our mapper functions
     // should not be called either.
-    fCurrDst = NULL;
+    fCurrBitmap = NULL;
     fCurrRC = NULL;
 
     if (!rc.isEmpty()) {
@@ -37,11 +38,12 @@
     }
 }
 
-SkDeviceLooper::~SkDeviceLooper() {}
+SkDeviceLooper::~SkDeviceLooper() {
+}
 
 void SkDeviceLooper::mapRect(SkRect* dst, const SkRect& src) const {
     SkASSERT(kDone_State != fState);
-    SkASSERT(fCurrDst);
+    SkASSERT(fCurrBitmap);
     SkASSERT(fCurrRC);
 
     *dst = src;
@@ -51,11 +53,12 @@
 
 void SkDeviceLooper::mapMatrix(SkMatrix* dst, const SkMatrix& src) const {
     SkASSERT(kDone_State != fState);
-    SkASSERT(fCurrDst);
+    SkASSERT(fCurrBitmap);
     SkASSERT(fCurrRC);
 
     *dst = src;
-    dst->postTranslate(SkIntToScalar(-fCurrOffset.fX), SkIntToScalar(-fCurrOffset.fY));
+    dst->postTranslate(SkIntToScalar(-fCurrOffset.fX),
+                       SkIntToScalar(-fCurrOffset.fY));
 }
 
 bool SkDeviceLooper::computeCurrBitmapAndClip() {
@@ -63,14 +66,16 @@
 
     SkIRect r = SkIRect::MakeXYWH(fCurrOffset.x(), fCurrOffset.y(),
                                   fDelta, fDelta);
-    if (!fBaseDst.extractSubset(&fSubsetDst, r)) {
+    if (!fBaseBitmap.extractSubset(&fSubsetBitmap, r)) {
         fSubsetRC.setEmpty();
     } else {
+        fSubsetBitmap.lockPixels();
         fBaseRC.translate(-r.left(), -r.top(), &fSubsetRC);
-        (void)fSubsetRC.op(SkIRect::MakeWH(fDelta, fDelta), SkRegion::kIntersect_Op);
+        (void)fSubsetRC.op(SkIRect::MakeWH(fDelta, fDelta),
+                           SkRegion::kIntersect_Op);
     }
 
-    fCurrDst = &fSubsetDst;
+    fCurrBitmap = &fSubsetBitmap;
     fCurrRC = &fSubsetRC;
     return !fCurrRC->isEmpty();
 }
@@ -102,8 +107,8 @@
 
         case kSimple_State:
             // first time for simple
-            if (NULL == fCurrDst) {
-                fCurrDst = &fBaseDst;
+            if (NULL == fCurrBitmap) {
+                fCurrBitmap = &fBaseBitmap;
                 fCurrRC = &fBaseRC;
                 fCurrOffset.set(0, 0);
                 return true;
diff --git a/src/core/SkDeviceLooper.h b/src/core/SkDeviceLooper.h
index dd346d7..a218345 100644
--- a/src/core/SkDeviceLooper.h
+++ b/src/core/SkDeviceLooper.h
@@ -30,13 +30,14 @@
  */
 class SkDeviceLooper {
 public:
-    SkDeviceLooper(const SkPixmap& base, const SkRasterClip&, const SkIRect& bounds, bool aa);
+    SkDeviceLooper(const SkBitmap& base, const SkRasterClip&,
+                   const SkIRect& bounds, bool aa);
     ~SkDeviceLooper();
 
-    const SkPixmap& getPixmap() const {
+    const SkBitmap& getBitmap() const {
         SkASSERT(kDone_State != fState);
-        SkASSERT(fCurrDst);
-        return *fCurrDst;
+        SkASSERT(fCurrBitmap);
+        return *fCurrBitmap;
     }
 
     const SkRasterClip& getRC() const {
@@ -60,7 +61,7 @@
     bool next();
 
 private:
-    const SkPixmap&     fBaseDst;
+    const SkBitmap&     fBaseBitmap;
     const SkRasterClip& fBaseRC;
 
     enum State {
@@ -70,10 +71,10 @@
     };
 
     // storage for our tiled versions. Perhaps could use SkTLazy
-    SkPixmap            fSubsetDst;
+    SkBitmap            fSubsetBitmap;
     SkRasterClip        fSubsetRC;
 
-    const SkPixmap*     fCurrDst;
+    const SkBitmap*     fCurrBitmap;
     const SkRasterClip* fCurrRC;
     SkIRect             fClippedBounds;
     SkIPoint            fCurrOffset;
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 0069087..ac69680 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -44,18 +44,20 @@
     SkAutoBlitterChoose() {
         fBlitter = NULL;
     }
-    SkAutoBlitterChoose(const SkPixmap& dst, const SkMatrix& matrix,
+    SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix,
                         const SkPaint& paint, bool drawCoverage = false) {
-        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
+        fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator,
+                                     drawCoverage);
     }
-    
+
     SkBlitter*  operator->() { return fBlitter; }
     SkBlitter*  get() const { return fBlitter; }
 
-    void choose(const SkPixmap& dst, const SkMatrix& matrix,
+    void choose(const SkBitmap& device, const SkMatrix& matrix,
                 const SkPaint& paint, bool drawCoverage = false) {
         SkASSERT(!fBlitter);
-        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
+        fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator,
+                                     drawCoverage);
     }
 
 private:
@@ -150,7 +152,8 @@
     memset(pixels, data, bytes);
 }
 
-static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& paint,
+static BitmapXferProc ChooseBitmapXferProc(const SkBitmap& bitmap,
+                                           const SkPaint& paint,
                                            uint32_t* data) {
     // todo: we can apply colorfilter up front if no shader, so we wouldn't
     // need to abort this fastpath
@@ -187,7 +190,7 @@
                 should I worry about dithering for the lower depths?
             */
             SkPMColor pmc = SkPreMultiplyColor(color);
-            switch (dst.colorType()) {
+            switch (bitmap.colorType()) {
                 case kN32_SkColorType:
                     if (data) {
                         *data = pmc;
@@ -217,10 +220,10 @@
     return NULL;
 }
 
-static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapXferProc proc,
-                               uint32_t procData) {
+static void CallBitmapXferProc(const SkBitmap& bitmap, const SkIRect& rect,
+                               BitmapXferProc proc, uint32_t procData) {
     int shiftPerPixel;
-    switch (dst.colorType()) {
+    switch (bitmap.colorType()) {
         case kN32_SkColorType:
             shiftPerPixel = 2;
             break;
@@ -235,9 +238,9 @@
             return;
     }
 
-    uint8_t* pixels = (uint8_t*)dst.writable_addr();
+    uint8_t* pixels = (uint8_t*)bitmap.getPixels();
     SkASSERT(pixels);
-    const size_t rowBytes = dst.rowBytes();
+    const size_t rowBytes = bitmap.rowBytes();
     const int widthBytes = rect.width() << shiftPerPixel;
 
     // skip down to the first scanline and X position
@@ -256,7 +259,7 @@
     }
 
     SkIRect    devRect;
-    devRect.set(0, 0, fDst.width(), fDst.height());
+    devRect.set(0, 0, fBitmap->width(), fBitmap->height());
 
     if (fRC->isBW()) {
         /*  If we don't have a shader (i.e. we're just a solid color) we may
@@ -266,7 +269,7 @@
             in the clip, we don't have to worry about antialiasing.
         */
         uint32_t procData = 0;  // to avoid the warning
-        BitmapXferProc proc = ChooseBitmapXferProc(fDst, paint, &procData);
+        BitmapXferProc proc = ChooseBitmapXferProc(*fBitmap, paint, &procData);
         if (proc) {
             if (D_Dst_BitmapXferProc == proc) { // nothing to do
                 return;
@@ -274,7 +277,7 @@
 
             SkRegion::Iterator iter(fRC->bwRgn());
             while (!iter.done()) {
-                CallBitmapXferProc(fDst, iter.rect(), proc, procData);
+                CallBitmapXferProc(*fBitmap, iter.rect(), proc, procData);
                 iter.next();
             }
             return;
@@ -282,7 +285,7 @@
     }
 
     // normal case: use a blitter
-    SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
+    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
     SkScan::FillIRect(devRect, *fRC, blitter.get());
 }
 
@@ -328,11 +331,11 @@
     SkASSERT(rec.fRC->isRect());
     const SkIRect& r = rec.fRC->getBounds();
     uint32_t value;
-    const SkPixmap* dst = blitter->justAnOpaqueColor(&value);
-    SkASSERT(dst);
+    const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value);
+    SkASSERT(bitmap);
 
-    uint16_t* addr = dst->writable_addr16(0, 0);
-    size_t    rb = dst->rowBytes();
+    uint16_t* addr = bitmap->getAddr16(0, 0);
+    size_t    rb = bitmap->rowBytes();
 
     for (int i = 0; i < count; i++) {
         int x = SkScalarFloorToInt(devPts[i].fX);
@@ -349,11 +352,11 @@
     SkASSERT(rec.fRC->isRect());
     const SkIRect& r = rec.fRC->getBounds();
     uint32_t value;
-    const SkPixmap* dst = blitter->justAnOpaqueColor(&value);
-    SkASSERT(dst);
+    const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value);
+    SkASSERT(bitmap);
 
-    SkPMColor* addr = dst->writable_addr32(0, 0);
-    size_t     rb = dst->rowBytes();
+    SkPMColor* addr = bitmap->getAddr32(0, 0);
+    size_t     rb = bitmap->rowBytes();
 
     for (int i = 0; i < count; i++) {
         int x = SkScalarFloorToInt(devPts[i].fX);
@@ -509,7 +512,7 @@
         if (fRadius <= SK_FixedHalf) {    // small radii and hairline
             if (SkCanvas::kPoints_PointMode == fMode && fClip->isRect()) {
                 uint32_t value;
-                const SkPixmap* bm = blitter->justAnOpaqueColor(&value);
+                const SkBitmap* bm = blitter->justAnOpaqueColor(&value);
                 if (bm && kRGB_565_SkColorType == bm->colorType()) {
                     proc = bw_pt_rect_16_hair_proc;
                 } else if (bm && kN32_SkColorType == bm->colorType()) {
@@ -556,7 +559,7 @@
 
     PtProcRec rec;
     if (!forceUseDevice && rec.init(mode, paint, fMatrix, fRC)) {
-        SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
+        SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
 
         SkPoint             devPts[MAX_DEV_PTS];
         const SkMatrix*     matrix = fMatrix;
@@ -850,14 +853,14 @@
         return;
     }
 
-    SkDeviceLooper looper(fDst, *fRC, ir, paint.isAntiAlias());
+    SkDeviceLooper looper(*fBitmap, *fRC, ir, paint.isAntiAlias());
     while (looper.next()) {
         SkRect localDevRect;
         looper.mapRect(&localDevRect, devRect);
         SkMatrix localMatrix;
         looper.mapMatrix(&localMatrix, *matrix);
 
-        SkAutoBlitterChoose blitterStorage(looper.getPixmap(), localMatrix, paint);
+        SkAutoBlitterChoose blitterStorage(looper.getBitmap(), localMatrix, paint);
         const SkRasterClip& clip = looper.getRC();
         SkBlitter*          blitter = blitterStorage.get();
 
@@ -908,7 +911,7 @@
     }
     SkAutoMaskFreeImage ami(dstM.fImage);
 
-    SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
+    SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint);
     SkBlitter* blitter = blitterChooser.get();
 
     SkAAClipBlitterWrapper wrapper;
@@ -986,7 +989,7 @@
         // Transform the rrect into device space.
         SkRRect devRRect;
         if (rrect.transform(*fMatrix, &devRRect)) {
-            SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
+            SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
             if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC, blitter.get(),
                                                    SkPaint::kFill_Style)) {
                 return; // filterRRect() called the blitter, so we're done
@@ -1105,7 +1108,7 @@
     SkBlitter* blitter = NULL;
     SkAutoBlitterChoose blitterStorage;
     if (NULL == customBlitter) {
-        blitterStorage.choose(fDst, *fMatrix, *paint, drawCoverage);
+        blitterStorage.choose(*fBitmap, *fMatrix, *paint, drawCoverage);
         blitter = blitterStorage.get();
     } else {
         blitter = customBlitter;
@@ -1179,7 +1182,7 @@
         // clipped to the actual device
         {
             SkIRect    devBounds;
-            devBounds.set(0, 0, fDst.width(), fDst.height());
+            devBounds.set(0, 0, fBitmap->width(), fBitmap->height());
             // need intersect(l, t, r, b) on irect
             if (!mask.fBounds.intersect(devBounds)) {
                 return;
@@ -1277,9 +1280,13 @@
         int ix = SkScalarRoundToInt(matrix.getTranslateX());
         int iy = SkScalarRoundToInt(matrix.getTranslateY());
         if (clipHandlesSprite(*fRC, ix, iy, pmap)) {
+            SkPixmap dstPM;
+            if (!fBitmap->peekPixels(&dstPM)) {
+                return;
+            }
             SkTBlitterAllocator allocator;
             // blitter will be owned by the allocator.
-            SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, ix, iy, &allocator);
+            SkBlitter* blitter = SkBlitter::ChooseSprite(dstPM, paint, pmap, ix, iy, &allocator);
             if (blitter) {
                 SkScan::FillIRect(SkIRect::MakeXYWH(ix, iy, pmap.width(), pmap.height()),
                                   *fRC, blitter);
@@ -1334,9 +1341,13 @@
     const SkPixmap& pmap = unlocker.pixmap();
 
     if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
+        SkPixmap dstPM;
+        if (!fBitmap->peekPixels(&dstPM)) {
+            return;
+        }
         SkTBlitterAllocator allocator;
         // blitter will be owned by the allocator.
-        SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator);
+        SkBlitter* blitter = SkBlitter::ChooseSprite(dstPM, paint, pmap, x, y, &allocator);
         if (blitter) {
             SkScan::FillIRect(bounds, *fRC, blitter);
             return;
@@ -1635,7 +1646,7 @@
     SkAutoBlitterChoose blitterChooser;
     SkBlitter*          blitter = NULL;
     if (needsRasterTextBlit(*this)) {
-        blitterChooser.choose(fDst, *fMatrix, paint);
+        blitterChooser.choose(*fBitmap, *fMatrix, paint);
         blitter = blitterChooser.get();
         if (fRC->isAA()) {
             aaBlitter.init(blitter, &fRC->aaRgn());
@@ -1754,7 +1765,7 @@
     SkAutoBlitterChoose blitterChooser;
     SkBlitter* blitter = NULL;
     if (needsRasterTextBlit(*this)) {
-        blitterChooser.choose(fDst, *fMatrix, paint);
+        blitterChooser.choose(*fBitmap, *fMatrix, paint);
         blitter = blitterChooser.get();
         if (fRC->isAA()) {
             wrapper.init(*fRC, blitter);
@@ -2084,7 +2095,7 @@
         }
     }
 
-    SkAutoBlitterChoose blitter(fDst, *fMatrix, p);
+    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, p);
     // Abort early if we failed to create a shader context.
     if (blitter->isNullBlitter()) {
         return;
@@ -2155,6 +2166,7 @@
 #ifdef SK_DEBUG
 
 void SkDraw::validate() const {
+    SkASSERT(fBitmap != NULL);
     SkASSERT(fMatrix != NULL);
     SkASSERT(fClip != NULL);
     SkASSERT(fRC != NULL);
@@ -2162,7 +2174,7 @@
     const SkIRect&  cr = fRC->getBounds();
     SkIRect         br;
 
-    br.set(0, 0, fDst.width(), fDst.height());
+    br.set(0, 0, fBitmap->width(), fBitmap->height());
     SkASSERT(cr.isEmpty() || br.contains(cr));
 }
 
@@ -2218,20 +2230,22 @@
     return true;
 }
 
-static void draw_into_mask(const SkMask& mask, const SkPath& devPath, SkPaint::Style style) {
-    SkDraw draw;
-    if (!draw.fDst.reset(mask)) {
-        return;
-    }
-
+static void draw_into_mask(const SkMask& mask, const SkPath& devPath,
+                           SkPaint::Style style) {
+    SkBitmap        bm;
+    SkDraw          draw;
     SkRasterClip    clip;
     SkMatrix        matrix;
     SkPaint         paint;
 
+    bm.installPixels(SkImageInfo::MakeA8(mask.fBounds.width(), mask.fBounds.height()),
+                     mask.fImage, mask.fRowBytes);
+
     clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
     matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
                         -SkIntToScalar(mask.fBounds.fTop));
 
+    draw.fBitmap    = &bm;
     draw.fRC        = &clip;
     draw.fClip      = &clip.bwRgn();
     draw.fMatrix    = &matrix;
diff --git a/src/core/SkScalerContext.cpp b/src/core/SkScalerContext.cpp
index 4ce42dd..7747cae 100644
--- a/src/core/SkScalerContext.cpp
+++ b/src/core/SkScalerContext.cpp
@@ -248,7 +248,7 @@
 }
 
 template<bool APPLY_PREBLEND>
-static void pack4xHToLCD16(const SkPixmap& src, const SkMask& dst,
+static void pack4xHToLCD16(const SkBitmap& src, const SkMask& dst,
                            const SkMaskGamma::PreBlend& maskPreBlend) {
 #define SAMPLES_PER_PIXEL 4
 #define LCD_PER_PIXEL 3
@@ -291,7 +291,7 @@
     };
 
     for (int y = 0; y < height; ++y) {
-        const uint8_t* srcP = src.addr8(0, y);
+        const uint8_t* srcP = src.getAddr8(0, y);
 
         // TODO: this fir filter implementation is straight forward, but slow.
         // It should be possible to make it much faster.
@@ -406,29 +406,29 @@
     clip.setRect(SkIRect::MakeWH(dstW, dstH));
 
     const SkImageInfo info = SkImageInfo::MakeA8(dstW, dstH);
-    SkAutoPixmapStorage dst;
+    SkBitmap bm;
 
     if (0 == dstRB) {
-        if (!dst.tryAlloc(info)) {
+        if (!bm.tryAllocPixels(info)) {
             // can't allocate offscreen, so empty the mask and return
             sk_bzero(mask.fImage, mask.computeImageSize());
             return;
         }
     } else {
-        dst.reset(info, mask.fImage, dstRB);
+        bm.installPixels(info, mask.fImage, dstRB);
     }
-    sk_bzero(dst.writable_addr(), dst.getSafeSize());
+    sk_bzero(bm.getPixels(), bm.getSafeSize());
 
     SkDraw  draw;
-    draw.fDst   = dst;
     draw.fRC    = &clip;
     draw.fClip  = &clip.bwRgn();
     draw.fMatrix = &matrix;
+    draw.fBitmap = &bm;
     draw.drawPath(path, paint);
 
     switch (mask.fFormat) {
         case SkMask::kBW_Format:
-            packA8ToA1(mask, dst.addr8(0, 0), dst.rowBytes());
+            packA8ToA1(mask, bm.getAddr8(0, 0), bm.rowBytes());
             break;
         case SkMask::kA8_Format:
             if (maskPreBlend.isApplicable()) {
@@ -437,9 +437,9 @@
             break;
         case SkMask::kLCD16_Format:
             if (maskPreBlend.isApplicable()) {
-                pack4xHToLCD16<true>(dst, mask, maskPreBlend);
+                pack4xHToLCD16<true>(bm, mask, maskPreBlend);
             } else {
-                pack4xHToLCD16<false>(dst, mask, maskPreBlend);
+                pack4xHToLCD16<false>(bm, mask, maskPreBlend);
             }
             break;
         default:
diff --git a/src/core/SkScan_Path.cpp b/src/core/SkScan_Path.cpp
index b7db3b4..9b4b9fd 100644
--- a/src/core/SkScan_Path.cpp
+++ b/src/core/SkScan_Path.cpp
@@ -344,7 +344,7 @@
     void blitMask(const SkMask&, const SkIRect& clip) override {
         SkDEBUGFAIL("blitMask unexpected");
     }
-    const SkPixmap* justAnOpaqueColor(uint32_t* value) override {
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) override {
         SkDEBUGFAIL("justAnOpaqueColor unexpected");
         return NULL;
     }
diff --git a/src/effects/SkLayerRasterizer.cpp b/src/effects/SkLayerRasterizer.cpp
index 8403d06..d3e112c 100644
--- a/src/effects/SkLayerRasterizer.cpp
+++ b/src/effects/SkLayerRasterizer.cpp
@@ -116,12 +116,9 @@
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
-        SkDraw          draw;
-        if (!draw.fDst.reset(*mask)) {
-            return false;
-        }
-
+        SkBitmap        device;
         SkRasterClip    rectClip;
+        SkDraw          draw;
         SkMatrix        translatedMatrix;  // this translates us to our local pixels
         SkMatrix        drawMatrix;        // this translates the path by each layer's offset
 
@@ -131,6 +128,9 @@
         translatedMatrix.postTranslate(-SkIntToScalar(mask->fBounds.fLeft),
                                        -SkIntToScalar(mask->fBounds.fTop));
 
+        device.installMaskPixels(*mask);
+
+        draw.fBitmap    = &device;
         draw.fMatrix    = &drawMatrix;
         draw.fRC        = &rectClip;
         draw.fClip      = &rectClip.bwRgn();
diff --git a/src/gpu/GrAADistanceFieldPathRenderer.cpp b/src/gpu/GrAADistanceFieldPathRenderer.cpp
index 3c7648a..21fbcb3 100755
--- a/src/gpu/GrAADistanceFieldPathRenderer.cpp
+++ b/src/gpu/GrAADistanceFieldPathRenderer.cpp
@@ -354,12 +354,14 @@
         SkIRect pathBounds = SkIRect::MakeWH(devPathBounds.width(),
                                              devPathBounds.height());
 
-        SkAutoPixmapStorage dst;
-        if (!dst.tryAlloc(SkImageInfo::MakeA8(pathBounds.width(),
-                                              pathBounds.height()))) {
+        SkBitmap bmp;
+        const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(pathBounds.fRight,
+                                                            pathBounds.fBottom);
+        if (!bmp.tryAllocPixels(bmImageInfo)) {
             return false;
         }
-        sk_bzero(dst.writable_addr(), dst.getSafeSize());
+
+        sk_bzero(bmp.getPixels(), bmp.getSafeSize());
 
         // rasterize path
         SkPaint paint;
@@ -386,7 +388,7 @@
         draw.fRC = &rasterClip;
         draw.fClip = &rasterClip.bwRgn();
         draw.fMatrix = &drawMatrix;
-        draw.fDst = dst;
+        draw.fBitmap = &bmp;
 
         draw.drawPathCoverage(path, paint);
 
@@ -398,9 +400,13 @@
         SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char));
 
         // Generate signed distance field
-        SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
-                                           (const unsigned char*)dst.addr(),
-                                           dst.width(), dst.height(), dst.rowBytes());
+        {
+            SkAutoLockPixels alp(bmp);
+
+            SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(),
+                                               (const unsigned char*)bmp.getPixels(),
+                                               bmp.width(), bmp.height(), bmp.rowBytes());
+        }
 
         // add to atlas
         SkIPoint16 atlasLocation;
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index 9b9865e..c13d2d8 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -146,8 +146,7 @@
     if (kBlitter_CompressionMode == fCompressionMode) {
         SkASSERT(fCompressedBuffer.get());
         blitter = SkTextureCompressor::CreateBlitterForFormat(
-            fPixels.width(), fPixels.height(), fCompressedBuffer.get(), &allocator,
-                                                              fCompressedFormat);
+            fBM.width(), fBM.height(), fCompressedBuffer.get(), &allocator, fCompressedFormat);
     }
 
     if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
@@ -203,26 +202,28 @@
         }
     } 
 
-    sk_bzero(&fDraw, sizeof(fDraw));
-
     // If we don't have a custom blitter, then we either need a bitmap to compress
     // from or a bitmap that we're going to use as a texture. In any case, we should
     // allocate the pixels for a bitmap
     const SkImageInfo bmImageInfo = SkImageInfo::MakeA8(cmpWidth, cmpHeight);
     if (kBlitter_CompressionMode != fCompressionMode) {
-        if (!fPixels.tryAlloc(bmImageInfo)) {
+        if (!fBM.tryAllocPixels(bmImageInfo)) {
             return false;
         }
-        fPixels.erase(0);
+
+        sk_bzero(fBM.getPixels(), fBM.getSafeSize());
     } else {
         // Otherwise, we just need to remember how big the buffer is...
-        fPixels.reset(bmImageInfo);
+        fBM.setInfo(bmImageInfo);
     }
-    fDraw.fDst      = fPixels;
+
+    sk_bzero(&fDraw, sizeof(fDraw));
+
     fRasterClip.setRect(bounds);
-    fDraw.fRC       = &fRasterClip;
-    fDraw.fClip     = &fRasterClip.bwRgn();
-    fDraw.fMatrix   = &fMatrix;
+    fDraw.fRC    = &fRasterClip;
+    fDraw.fClip  = &fRasterClip.bwRgn();
+    fDraw.fMatrix = &fMatrix;
+    fDraw.fBitmap = &fBM;
     return true;
 }
 
@@ -231,8 +232,8 @@
  */
 GrTexture* GrSWMaskHelper::createTexture() {
     GrSurfaceDesc desc;
-    desc.fWidth = fPixels.width();
-    desc.fHeight = fPixels.height();
+    desc.fWidth = fBM.width();
+    desc.fHeight = fBM.height();
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     if (kNone_CompressionMode != fCompressionMode) {
@@ -272,8 +273,7 @@
     SkASSERT(GrPixelConfigIsCompressed(desc.fConfig));
     SkASSERT(fmt_to_config(fCompressedFormat) == desc.fConfig);
 
-    SkAutoDataUnref cmpData(SkTextureCompressor::CompressBitmapToFormat(fPixels,
-                                                                        fCompressedFormat));
+    SkAutoDataUnref cmpData(SkTextureCompressor::CompressBitmapToFormat(fBM, fCompressedFormat));
     SkASSERT(cmpData);
 
     this->sendTextureData(texture, desc, cmpData->data(), 0);
@@ -283,15 +283,17 @@
  * Move the result of the software mask generation back to the gpu
  */
 void GrSWMaskHelper::toTexture(GrTexture *texture) {
+    SkAutoLockPixels alp(fBM);
+
     GrSurfaceDesc desc;
-    desc.fWidth = fPixels.width();
-    desc.fHeight = fPixels.height();
+    desc.fWidth = fBM.width();
+    desc.fHeight = fBM.height();
     desc.fConfig = texture->config();
         
     // First see if we should compress this texture before uploading.
     switch (fCompressionMode) {
         case kNone_CompressionMode:
-            this->sendTextureData(texture, desc, fPixels.addr(), fPixels.rowBytes());
+            this->sendTextureData(texture, desc, fBM.getPixels(), fBM.rowBytes());
             break;
 
         case kCompress_CompressionMode:
@@ -309,8 +311,10 @@
  * Convert mask generation results to a signed distance field
  */
 void GrSWMaskHelper::toSDF(unsigned char* sdf) {
-    SkGenerateDistanceFieldFromA8Image(sdf, (const unsigned char*)fPixels.addr(),
-                                       fPixels.width(), fPixels.height(), fPixels.rowBytes());
+    SkAutoLockPixels alp(fBM);
+    
+    SkGenerateDistanceFieldFromA8Image(sdf, (const unsigned char*)fBM.getPixels(),
+                                       fBM.width(), fBM.height(), fBM.rowBytes());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/GrSWMaskHelper.h b/src/gpu/GrSWMaskHelper.h
index b90205b..a69e4be 100644
--- a/src/gpu/GrSWMaskHelper.h
+++ b/src/gpu/GrSWMaskHelper.h
@@ -69,7 +69,7 @@
     
     // Reset the internal bitmap
     void clear(uint8_t alpha) {
-        fPixels.erase(SkColorSetARGB(alpha, 0xFF, 0xFF, 0xFF));
+        fBM.eraseColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
     }
 
     // Canonical usage utility that draws a single path and uploads it
@@ -105,7 +105,7 @@
 
     GrContext*      fContext;
     SkMatrix        fMatrix;
-    SkAutoPixmapStorage fPixels;
+    SkBitmap        fBM;
     SkDraw          fDraw;
     SkRasterClip    fRasterClip;
 
diff --git a/src/utils/SkTextureCompressor.cpp b/src/utils/SkTextureCompressor.cpp
index 9d29d51..12621e1 100644
--- a/src/utils/SkTextureCompressor.cpp
+++ b/src/utils/SkTextureCompressor.cpp
@@ -173,17 +173,19 @@
     return false;
 }
 
-SkData* CompressBitmapToFormat(const SkPixmap& pixmap, Format format) {
-    int compressedDataSize = GetCompressedDataSize(format, pixmap.width(), pixmap.height());
+SkData* CompressBitmapToFormat(const SkBitmap &bitmap, Format format) {
+    SkAutoLockPixels alp(bitmap);
+
+    int compressedDataSize = GetCompressedDataSize(format, bitmap.width(), bitmap.height());
     if (compressedDataSize < 0) {
         return NULL;
     }
 
-    const uint8_t* src = reinterpret_cast<const uint8_t*>(pixmap.addr());
+    const uint8_t* src = reinterpret_cast<const uint8_t*>(bitmap.getPixels());
     SkData* dst = SkData::NewUninitialized(compressedDataSize);
 
-    if (!CompressBufferToFormat((uint8_t*)dst->writable_data(), src, pixmap.colorType(),
-                                pixmap.width(), pixmap.height(), pixmap.rowBytes(), format)) {
+    if (!CompressBufferToFormat((uint8_t*)dst->writable_data(), src, bitmap.colorType(),
+                                bitmap.width(), bitmap.height(), bitmap.rowBytes(), format)) {
         dst->unref();
         dst = NULL;
     }
diff --git a/src/utils/SkTextureCompressor.h b/src/utils/SkTextureCompressor.h
index e31a5ab..e35bc95 100644
--- a/src/utils/SkTextureCompressor.h
+++ b/src/utils/SkTextureCompressor.h
@@ -55,10 +55,10 @@
     int GetCompressedDataSize(Format fmt, int width, int height);
 
     // Returns an SkData holding a blob of compressed data that corresponds
-    // to the pixmap. If the pixmap colorType cannot be compressed using the 
+    // to the bitmap. If the bitmap colorType cannot be compressed using the 
     // associated format, then we return NULL. The caller is responsible for
     // calling unref() on the returned data.
-    SkData* CompressBitmapToFormat(const SkPixmap&, Format format);
+    SkData* CompressBitmapToFormat(const SkBitmap& bitmap, Format format);
 
     // Compresses the given src data into dst. The src data is assumed to be
     // large enough to hold width*height pixels. The dst data is expected to
diff --git a/src/utils/SkTextureCompressor_Blitter.h b/src/utils/SkTextureCompressor_Blitter.h
index e522375..73d8ee4 100644
--- a/src/utils/SkTextureCompressor_Blitter.h
+++ b/src/utils/SkTextureCompressor_Blitter.h
@@ -368,7 +368,7 @@
     // If the blitter just sets a single value for each pixel, return the
     // bitmap it draws into, and assign value. If not, return NULL and ignore
     // the value parameter.
-    const SkPixmap* justAnOpaqueColor(uint32_t* value) override {
+    const SkBitmap* justAnOpaqueColor(uint32_t* value) override {
         return NULL;
     }