Revert of change SkDraw and all Blitters to use pixmap instead of bitmap

src/core/SkBlitter.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlitter.h"
 #include "SkAntiRun.h"
 #include "SkColor.h"
@@ skipping 15 matching lines @@
 bool SkBlitter::isNullBlitter() const { return false; }
 
 bool SkBlitter::resetShaderContext(const SkShader::ContextRec&) {
     return true;
 }
 
 SkShader::Context* SkBlitter::getShaderContext() const {
     return NULL;
 }
 
-const SkPixmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkBlitter::justAnOpaqueColor(uint32_t* value) {
     return NULL;
 }
 
 void SkBlitter::blitH(int x, int y, int width) {
     SkDEBUGFAIL("unimplemented");
 }
 
 void SkBlitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                           const int16_t runs[]) {
     SkDEBUGFAIL("unimplemented");
@@ skipping 189 matching lines @@
 
 void SkNullBlitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                               const int16_t runs[]) {}
 
 void SkNullBlitter::blitV(int x, int y, int height, SkAlpha alpha) {}
 
 void SkNullBlitter::blitRect(int x, int y, int width, int height) {}
 
 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;
 }
 
 bool SkNullBlitter::isNullBlitter() const { return true; }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static int compute_anti_width(const int16_t runs[]) {
     int width = 0;
 
@@ skipping 140 matching lines @@
 void SkRectClipBlitter::blitMask(const SkMask& mask, const SkIRect& clip) {
     SkASSERT(mask.fBounds.contains(clip));
 
     SkIRect    r = clip;
 
     if (r.intersect(fClipRect)) {
         fBlitter->blitMask(mask, r);
     }
 }
 
-const SkPixmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRectClipBlitter::justAnOpaqueColor(uint32_t* value) {
     return fBlitter->justAnOpaqueColor(value);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkRgnClipBlitter::blitH(int x, int y, int width) {
     SkRegion::Spanerator span(*fRgn, y, x, x + width);
     int left, right;
 
     while (span.next(&left, &right)) {
@@ skipping 115 matching lines @@
     SkRegion::Cliperator iter(*fRgn, clip);
     const SkIRect&       r = iter.rect();
     SkBlitter*           blitter = fBlitter;
 
     while (!iter.done()) {
         blitter->blitMask(mask, r);
         iter.next();
     }
 }
 
-const SkPixmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
+const SkBitmap* SkRgnClipBlitter::justAnOpaqueColor(uint32_t* value) {
     return fBlitter->justAnOpaqueColor(value);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlitter* SkBlitterClipper::apply(SkBlitter* blitter, const SkRegion* clip,
                                    const SkIRect* ir) {
     if (clip) {
         const SkIRect& clipR = clip->getBounds();
 
@@ skipping 217 matching lines @@
 private:
     // Both pointers are unowned. They will be deleted by SkSmallAllocator.
     SkBlitter*          fProxy;
     SkShader::Context*  fShaderContext;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkCoreBlitters.h"
 
-SkBlitter* SkBlitter::Choose(const SkPixmap& device,
+SkBlitter* SkBlitter::Choose(const SkBitmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
                              SkTBlitterAllocator* allocator,
                              bool drawCoverage) {
     SkASSERT(allocator != NULL);
 
     // which check, in case we're being called by a client with a dummy device
     // (e.g. they have a bounder that always aborts the draw)
     if (kUnknown_SkColorType == device.colorType() ||
             (drawCoverage && (kAlpha_8_SkColorType != device.colorType()))) {
@@ skipping 145 matching lines @@
         : INHERITED(shader, SkShader::ContextRec(*rec.fPaint, SkMatrix::I(), NULL)) {}
 
     void shadeSpan(int x, int y, SkPMColor colors[], int count) override {
         sk_bzero(colors, count * sizeof(SkPMColor));
     }
 
 private:
     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())
         , fShaderContext(shaderContext) {
     SkASSERT(fShader);
     SkASSERT(fShaderContext);
 
     fShader->ref();
     fShaderFlags = fShaderContext->getFlags();
 }
@@ skipping 11 matching lines @@
     fShaderContext->~Context();
     SkShader::Context* ctx = fShader->createContext(rec, (void*)fShaderContext);
     if (NULL == ctx) {
         // Need a valid context in fShaderContext's storage, so we can later (or our caller) call
         // the in-place destructor.
         SkNEW_PLACEMENT_ARGS(fShaderContext, SkZeroShaderContext, (*fShader, rec));
         return false;
     }
     return true;
 }