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

src/core/SkScalerContext.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 "SkScalerContext.h"
@@ skipping 230 matching lines @@
 
     for (int y = mask.fBounds.height() - 1; y >= 0; --y) {
         for (int x = mask.fBounds.width() - 1; x >= 0; --x) {
             dst[x] = lut[dst[x]];
         }
         dst += rowBytes;
     }
 }
 
 template<bool APPLY_PREBLEND>
-static void pack4xHToLCD16(const SkBitmap& src, const SkMask& dst,
+static void pack4xHToLCD16(const SkPixmap& src, const SkMask& dst,
                            const SkMaskGamma::PreBlend& maskPreBlend) {
 #define SAMPLES_PER_PIXEL 4
 #define LCD_PER_PIXEL 3
     SkASSERT(kAlpha_8_SkColorType == src.colorType());
     SkASSERT(SkMask::kLCD16_Format == dst.fFormat);
 
     const int sample_width = src.width();
     const int height = src.height();
 
     uint16_t* dstP = (uint16_t*)dst.fImage;
@@ skipping 22 matching lines @@
     static const unsigned int coefficients[LCD_PER_PIXEL][SAMPLES_PER_PIXEL*3] = {
         //The red subpixel is centered inside the first sample (at 1/6 pixel), and is shifted.
         { 0x03, 0x0b, 0x1c, 0x33,  0x40, 0x39, 0x24, 0x10,  0x05, 0x01, 0x00, 0x00, },
         //The green subpixel is centered between two samples (at 1/2 pixel), so is symetric
         { 0x00, 0x02, 0x08, 0x16,  0x2b, 0x3d, 0x3d, 0x2b,  0x16, 0x08, 0x02, 0x00, },
         //The blue subpixel is centered inside the last sample (at 5/6 pixel), and is shifted.
         { 0x00, 0x00, 0x01, 0x05,  0x10, 0x24, 0x39, 0x40,  0x33, 0x1c, 0x0b, 0x03, },
     };
 
     for (int y = 0; y < height; ++y) {
-        const uint8_t* srcP = src.getAddr8(0, y);
+        const uint8_t* srcP = src.addr8(0, y);
 
         // TODO: this fir filter implementation is straight forward, but slow.
         // It should be possible to make it much faster.
         for (int sample_x = -4, pixel_x = 0; sample_x < sample_width + 4; sample_x += 4, ++pixel_x) {
             int fir[LCD_PER_PIXEL] = { 0 };
             for (int sample_index = SkMax32(0, sample_x - 4), coeff_index = sample_index - (sample_x - 4)
                 ; sample_index < SkMin32(sample_x + 8, sample_width)
                 ; ++sample_index, ++coeff_index)
             {
                 int sample_value = srcP[sample_index];
@@ skipping 94 matching lines @@
             dstRB = 0;  // signals we need a copy
             break;
         default:
             SkDEBUGFAIL("unexpected mask format");
     }
 
     SkRasterClip clip;
     clip.setRect(SkIRect::MakeWH(dstW, dstH));
 
     const SkImageInfo info = SkImageInfo::MakeA8(dstW, dstH);
-    SkBitmap bm;
+    SkAutoPixmapStorage dst;
 
     if (0 == dstRB) {
-        if (!bm.tryAllocPixels(info)) {
+        if (!dst.tryAlloc(info)) {
             // can't allocate offscreen, so empty the mask and return
             sk_bzero(mask.fImage, mask.computeImageSize());
             return;
         }
     } else {
-        bm.installPixels(info, mask.fImage, dstRB);
+        dst.reset(info, mask.fImage, dstRB);
     }
-    sk_bzero(bm.getPixels(), bm.getSafeSize());
+    sk_bzero(dst.writable_addr(), dst.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, bm.getAddr8(0, 0), bm.rowBytes());
+            packA8ToA1(mask, dst.addr8(0, 0), dst.rowBytes());
             break;
         case SkMask::kA8_Format:
             if (maskPreBlend.isApplicable()) {
                 applyLUTToA8Mask(mask, maskPreBlend.fG);
             }
             break;
         case SkMask::kLCD16_Format:
             if (maskPreBlend.isApplicable()) {
-                pack4xHToLCD16<true>(bm, mask, maskPreBlend);
+                pack4xHToLCD16<true>(dst, mask, maskPreBlend);
             } else {
-                pack4xHToLCD16<false>(bm, mask, maskPreBlend);
+                pack4xHToLCD16<false>(dst, mask, maskPreBlend);
             }
             break;
         default:
             break;
     }
 }
 
 static void extract_alpha(const SkMask& dst,
                           const SkPMColor* srcRow, size_t srcRB) {
     int width = dst.fBounds.width();
@@ skipping 416 matching lines @@
 SkScalerContext* SkTypeface::createScalerContext(const SkDescriptor* desc,
                                                  bool allowFailure) const {
     SkScalerContext* c = this->onCreateScalerContext(desc);
 
     if (!c && !allowFailure) {
         c = SkNEW_ARGS(SkScalerContext_Empty,
                        (const_cast<SkTypeface*>(this), desc));
     }
     return c;
 }