Revert[2] SkDraw and all Blitters to use pixmap instead of bitmapi

tests/DeviceLooperTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDeviceLooper.h"
 #include "SkRasterClip.h"
 #include "Test.h"
 
-static void make_bm(SkBitmap* bm, int w, int h) {
-    bm->allocPixels(SkImageInfo::Make(w, h, kAlpha_8_SkColorType,
-                                      kPremul_SkAlphaType));
+static void make_pm(SkAutoPixmapStorage* pixmap, int w, int h) {
+    pixmap->alloc(SkImageInfo::Make(w, h, kAlpha_8_SkColorType, kPremul_SkAlphaType));
 }
 
 static bool equal(const SkRasterClip& a, const SkRasterClip& b) {
     if (a.isBW()) {
         return b.isBW() && a.bwRgn() == b.bwRgn();
     } else {
         return a.isAA() && a.aaRgn() == b.aaRgn();
     }
 }
 
 static const struct {
     SkISize fDevSize;
     SkIRect fRCBounds;
     SkIRect fRect;
 } gRec[] = {
     { { 4000, 10 }, { 0, 0, 4000, 10 }, { 0, 0, 4000, 4000 } },
     { { 10, 4000 }, { 0, 0, 10, 4000 }, { 0, 0, 4000, 4000 } },
     // very large devce, small rect
     { { 32000, 10 }, { 0, 0, 32000, 10 }, { 0, 0, 4000, 4000 } },
     { { 10, 32000 }, { 0, 0, 10, 32000 }, { 0, 0, 4000, 4000 } },
     // very large device, small clip
     { { 32000, 10 }, { 0, 0, 4000, 10 }, { 0, 0, 32000, 32000 } },
     { { 10, 32000 }, { 0, 0, 10, 4000 }, { 0, 0, 32000, 32000 } },
 };
 
 static void test_simple(skiatest::Reporter* reporter) {
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
-        SkBitmap bitmap;
-        make_bm(&bitmap, gRec[i].fDevSize.width(), gRec[i].fDevSize.height());
+        SkAutoPixmapStorage pmap;
+        make_pm(&pmap, gRec[i].fDevSize.width(), gRec[i].fDevSize.height());
 
         SkRasterClip rc(gRec[i].fRCBounds);
 
         for (int aa = 0; aa <= 1; ++aa) {
-            SkDeviceLooper looper(bitmap, rc, gRec[i].fRect, SkToBool(aa));
+            SkDeviceLooper looper(pmap, rc, gRec[i].fRect, SkToBool(aa));
 
             bool valid = looper.next();
             REPORTER_ASSERT(reporter, valid);
             if (valid) {
-                REPORTER_ASSERT(reporter, looper.getBitmap().width() == bitmap.width());
-                REPORTER_ASSERT(reporter, looper.getBitmap().height() == bitmap.height());
+                REPORTER_ASSERT(reporter, looper.getPixmap().width() == pmap.width());
+                REPORTER_ASSERT(reporter, looper.getPixmap().height() == pmap.height());
                 REPORTER_ASSERT(reporter, equal(looper.getRC(), rc));
 
                 REPORTER_ASSERT(reporter, !looper.next());
             }
         }
         // test that a rect that doesn't intersect returns no loops
         {
             SkIRect r = rc.getBounds();
             r.offset(r.width(), 0);
-            SkDeviceLooper looper(bitmap, rc, r, false);
+            SkDeviceLooper looper(pmap, rc, r, false);
             REPORTER_ASSERT(reporter, !looper.next());
         }
     }
 }
 
 // mask-bits are interpreted as the areas where the clip is visible
 //  [ 0x01  0x02 ]
 //  [ 0x04  0x08 ]
 //
 static void make_rgn(SkRegion* rgn, int w, int h, unsigned mask) {
@@ skipping 26 matching lines @@
         bool    fAA;
     } const gRec[] = {
         { { BW_SIZE, BW_SIZE }, false },
         { {  AA_SIZE, AA_SIZE }, true },
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         const int w = gRec[i].fSize.width();
         const int h = gRec[i].fSize.height();
 
-        SkBitmap bitmap;
-        make_bm(&bitmap, w, h);
+        SkAutoPixmapStorage pmap;
+        make_pm(&pmap, w, h);
 
         const SkIRect rect = SkIRect::MakeWH(w, h);
 
         // mask-bits are interpreted as the areas where the clip is visible
         //  [ 0x01  0x02 ]
         //  [ 0x04  0x08 ]
         //
         for (int mask = 0; mask <= 15; ++mask) {
             SkRegion rgn;
             make_rgn(&rgn, w, h, mask);
 
             SkRasterClip rc;
             rc.op(rgn, SkRegion::kReplace_Op);
 
-            SkDeviceLooper looper(bitmap, rc, rect, gRec[i].fAA);
+            SkDeviceLooper looper(pmap, rc, rect, gRec[i].fAA);
             while (looper.next()) {
                 REPORTER_ASSERT(reporter, !looper.getRC().isEmpty());
             }
         }
     }
 }
 
 DEF_TEST(DeviceLooper, reporter) {
     test_simple(reporter);
     test_complex(reporter);
 }