change SkDraw and all Blitters to use pixmap instead of bitmap

src/core/SkDeviceLooper.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkDeviceLooper_DEFINED
 #define SkDeviceLooper_DEFINED
 
@@ skipping 12 matching lines @@
  *  add/subtract two fixed values and still be in range. If we're drawing AA,
  *  then we reduce that size by the amount that the supersampler scan converter
  *  needs (at the moment, that is 4X, so the "safe" range is +- 4K).
  *
  *  For performance reasons, the class first checks to see if any help is needed
  *  at all, and if not (i.e. the specified bounds and base bitmap area already
  *  in the safe-zone, then the class does nothing (effectively).
  */
 class SkDeviceLooper {
 public:
-    SkDeviceLooper(const SkBitmap& base, const SkRasterClip&,
-                   const SkIRect& bounds, bool aa);
+    SkDeviceLooper(const SkPixmap& base, const SkRasterClip&, const SkIRect& bounds, bool aa);
     ~SkDeviceLooper();
 
-    const SkBitmap& getBitmap() const {
+    const SkPixmap& getPixmap() const {
         SkASSERT(kDone_State != fState);
-        SkASSERT(fCurrBitmap);
-        return *fCurrBitmap;
+        SkASSERT(fCurrDst);
+        return *fCurrDst;
     }
 
     const SkRasterClip& getRC() const {
         SkASSERT(kDone_State != fState);
         SkASSERT(fCurrRC);
         return *fCurrRC;
     }
 
     void mapRect(SkRect* dst, const SkRect& src) const;
     void mapMatrix(SkMatrix* dst, const SkMatrix& src) const;
 
     /**
      *  Call next to setup the looper to return a valid coordinate chunk.
      *  Each time this returns true, it is safe to call mapRect() and
      *  mapMatrix(), to convert from "global" coordinate values to ones that
      *  are local to this chunk.
      *
      *  When next() returns false, the list of chunks is done, and mapRect()
      *  and mapMatrix() should no longer be called.
      */
     bool next();
 
 private:
-    const SkBitmap&     fBaseBitmap;
+    const SkPixmap&     fBaseDst;
     const SkRasterClip& fBaseRC;
 
     enum State {
         kDone_State,    // iteration is complete, getters will assert
         kSimple_State,  // no translate/clip mods needed
         kComplex_State
     };
 
     // storage for our tiled versions. Perhaps could use SkTLazy
-    SkBitmap            fSubsetBitmap;
+    SkPixmap            fSubsetDst;
     SkRasterClip        fSubsetRC;
 
-    const SkBitmap*     fCurrBitmap;
+    const SkPixmap*     fCurrDst;
     const SkRasterClip* fCurrRC;
     SkIRect             fClippedBounds;
     SkIPoint            fCurrOffset;
     int                 fDelta;
     State               fState;
 
     enum Delta {
         kBW_Delta = 1 << 14,        // 16K, gives room to spare for fixedpoint
         kAA_Delta = kBW_Delta >> 2  // supersample 4x
     };
 
     bool fitsInDelta(const SkIRect& r) const {
         return r.right() < fDelta && r.bottom() < fDelta;
     }
 
     bool computeCurrBitmapAndClip();
 };
 
 #endif