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

src/core/SkBlitter.h

 /*
  * 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.
  */
 
 #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"
 #include "SkSmallAllocator.h"
 
 /** SkBlitter and its subclasses are responsible for actually writing pixels
     into memory. Besides efficiency, they handle clipping and antialiasing.
 */
 class SkBlitter {
 public:
@@ skipping 18 matching lines @@
     virtual void blitAntiRect(int x, int y, int width, int height,
                               SkAlpha leftAlpha, SkAlpha rightAlpha);
     /// Blit a pattern of pixels defined by a rectangle-clipped mask;
     /// typically used for text.
     virtual void blitMask(const SkMask&, const SkIRect& clip);
 
     /** 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.
     */
-    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) {
         int16_t runs[3];
         uint8_t aa[2];
         
         runs[0] = 1;
         runs[1] = 1;
         runs[2] = 0;
         aa[0] = SkToU8(a0);
@@ skipping 50 matching lines @@
 
     ///@name non-virtual helpers
     void blitMaskRegion(const SkMask& mask, const SkRegion& clip);
     void blitRectRegion(const SkIRect& rect, const SkRegion& clip);
     void blitRegion(const SkRegion& clip);
     ///@}
 
     /** @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*,
                              bool drawCoverage = false);
 
     static SkBlitter* ChooseSprite(const SkPixmap& dst,
                                    const SkPaint&,
                                    const SkPixmap& src,
                                    int left, int top,
                                    SkTBlitterAllocator*);
     ///@}
 
 protected:
 
     SkAutoMalloc fBlitMemory;
     
 private:
 };
 
 /** This blitter silently never draws anything.
 */
 class SkNullBlitter : public SkBlitter {
 public:
     void blitH(int x, int y, int width) 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;
     bool isNullBlitter() const override;
 };
 
 /** Wraps another (real) blitter, and ensures that the real blitter is only
     called with coordinates that have been clipped by the specified clipRect.
     This means the caller need not perform the clipping ahead of time.
 */
 class SkRectClipBlitter : public SkBlitter {
 public:
     void init(SkBlitter* blitter, const SkIRect& clipRect) {
         SkASSERT(!clipRect.isEmpty());
         fBlitter = blitter;
         fClipRect = clipRect;
     }
 
     void blitH(int x, int y, int width) 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;
     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();
     }
 
     void* allocBlitMemory(size_t sz) override {
         return fBlitter->allocBlitMemory(sz);
     }
 
 private:
@@ skipping 14 matching lines @@
     }
 
     void blitH(int x, int y, int width) 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;
     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();
     }
 
     void* allocBlitMemory(size_t sz) override {
         return fBlitter->allocBlitMemory(sz);
     }
 
 private:
@@ skipping 10 matching lines @@
     SkBlitter*  apply(SkBlitter* blitter, const SkRegion* clip,
                       const SkIRect* bounds = NULL);
 
 private:
     SkNullBlitter       fNullBlitter;
     SkRectClipBlitter   fRectBlitter;
     SkRgnClipBlitter    fRgnBlitter;
 };
 
 #endif