add peekPixels to canvas

gm/aaclip.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkCanvas.h"
 #include "SkPath.h"
+#include "SkSurface.h"
 
 static void test_quadstroke(SkCanvas* canvas) {
     SkPath path;
     path.moveTo(6, 0);
     path.quadTo(150, 150, 0, 6);
 
     SkPaint paint;
 
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kStroke_Style);
@@ skipping 94 matching lines @@
         { 602.455933f, 625.204102f },
     };
     SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, SK_ColorRED, SK_ColorRED };
     SkScalar pos[] = { 0, 0.3f, 0.3f, 1.0f };
     SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode);
     SkPaint p;
     p.setShader(s)->unref();
     canvas->drawPaint(p);
 }
 
-static SkCanvas* MakeCanvas(const SkIRect& bounds) {
-    SkBitmap bm;
-    bm.allocN32Pixels(bounds.width(), bounds.height());
-    bm.eraseColor(SK_ColorTRANSPARENT);
-
-    SkCanvas* canvas = new SkCanvas(bm);
-    canvas->translate(-SkIntToScalar(bounds.fLeft), -SkIntToScalar(bounds.fTop));
-    return canvas;
+static SkSurface* MakeSurface(const SkIRect& bounds) {
+    SkImageInfo info = SkImageInfo::MakeN32Premul(bounds.width(),
+                                                  bounds.height());
+    SkSurface* surface = SkSurface::NewRaster(info);
+    surface->getCanvas()->clear(0);
+    surface->getCanvas()->translate(-SkIntToScalar(bounds.fLeft),
+                                    -SkIntToScalar(bounds.fTop));
+    return surface;
 }
 
+static void compare(SkSurface* a, SkSurface* b) {
 #ifdef SK_DEBUG
-static void GetBitmap(const SkCanvas* canvas, SkBitmap* bm) {
-    *bm = canvas->getDevice()->accessBitmap(false);
-}
-#endif
+    SkImageInfo infoa, infob;
+    size_t rowBytesa, rowBytesb;
 
-static void compare_canvas(const SkCanvas* a, const SkCanvas* b) {
-#ifdef SK_DEBUG
+    const void* pa = a->peekPixels(&infoa, &rowBytesa);
+    const void* pb = b->peekPixels(&infob, &rowBytesb);
+    SkASSERT(pa && pb);
+
     SkBitmap bma, bmb;
-    GetBitmap(a, &bma);
-    GetBitmap(b, &bmb);
+    bma.installPixels(infoa, const_cast<void*>(pa), rowBytesa, NULL, NULL);
+    bmb.installPixels(infob, const_cast<void*>(pb), rowBytesb, NULL, NULL);
 
     SkASSERT(bma.width() == bmb.width());
     SkASSERT(bma.height() == bmb.height());
 
     bma.lockPixels();
     bmb.lockPixels();
     for (int y = 0; y < bma.height(); ++y) {
         const SkPMColor* rowa = bma.getAddr32(0, y);
         const SkPMColor* rowb = bmb.getAddr32(0, y);
         SkASSERT(!memcmp(rowa, rowb, bma.width() << 2));
@@ skipping 12 matching lines @@
     canvas->drawPath(path, p);
 }
 
 static void test_maskFromPath(const SkPath& path) {
     SkIRect bounds;
     path.getBounds().roundOut(&bounds);
 
     SkPaint paint;
     paint.setAntiAlias(true);
 
-    SkAutoTUnref<SkCanvas> path_canvas(MakeCanvas(bounds));
-    path_canvas->drawPath(path, paint);
+    SkAutoTUnref<SkSurface> path_surface(MakeSurface(bounds));
+    path_surface->getCanvas()->drawPath(path, paint);
 
-    SkAutoTUnref<SkCanvas> rect_canvas(MakeCanvas(bounds));
-    drawRectAsPath(rect_canvas, path.getBounds(), paint);
+    SkAutoTUnref<SkSurface> rect_surface(MakeSurface(bounds));
+    drawRectAsPath(rect_surface->getCanvas(), path.getBounds(), paint);
 
-    compare_canvas(path_canvas, rect_canvas);
+    compare(path_surface, rect_surface);
 }
 
 static void test_mask() {
     for (int i = 1; i <= 20; ++i) {
         const SkScalar dx = SK_Scalar1 / i;
         const SkRect constr = SkRect::MakeWH(dx, SkIntToScalar(2));
         for (int n = 2; n < 20; ++n) {
             SkPath path;
             path.setFillType(SkPath::kEvenOdd_FillType);
             SkRect r = constr;
@@ skipping 83 matching lines @@
             SkRect bounds;
             canvas->getClipBounds(&bounds);
             test_shallow_gradient(canvas, bounds.width(), bounds.height()); return;
         }
         if (false) {
             test_giant_dash(canvas); return;
         }
         if (false) {
             test_grad(canvas); return;
         }
-        if (false) { // avoid bit rot, suppress warning
+        if (true) { // avoid bit rot, suppress warning
             test_mask();
         }
 
         // Initial pixel-boundary-aligned draw
         draw_rect_tests(canvas);
 
         // Repeat 4x with .2, .4, .6, .8 px offsets
         canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
         canvas->translate(SkIntToScalar(50), 0);
         draw_rect_tests(canvas);
@@ skipping 11 matching lines @@
         draw_rect_tests(canvas);
     }
 
     virtual uint32_t onGetFlags() const { return kSkipPipe_Flag; }
 
 private:
     typedef skiagm::GM INHERITED;
 };
 
 DEF_GM( return SkNEW(AAClipGM); )