Home | History | Annotate | Download | only in tests
      1 
      2 /*
      3  * Copyright 2012 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 #include "Test.h"
      9 #include "SkBitmap.h"
     10 #include "SkBitmapDevice.h"
     11 #include "SkBitmapProcShader.h"
     12 #include "SkDeferredCanvas.h"
     13 #include "SkGradientShader.h"
     14 #include "SkShader.h"
     15 #include "../src/image/SkSurface_Base.h"
     16 #include "../src/image/SkImagePriv.h"
     17 #if SK_SUPPORT_GPU
     18 #include "GrContextFactory.h"
     19 #else
     20 class GrContextFactory;
     21 #endif
     22 
     23 static const int gWidth = 2;
     24 static const int gHeight = 2;
     25 
     26 static void create(SkBitmap* bm, SkBitmap::Config config, SkColor color) {
     27     bm->setConfig(config, gWidth, gHeight);
     28     bm->allocPixels();
     29     bm->eraseColor(color);
     30 }
     31 
     32 static void TestDeferredCanvasBitmapAccess(skiatest::Reporter* reporter) {
     33     SkBitmap store;
     34 
     35     create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
     36     SkBitmapDevice device(store);
     37     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
     38 
     39     canvas->clear(0x00000000);
     40 
     41     SkAutoLockPixels alp(store);
     42     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
     43     SkBitmap accessed = canvas->getDevice()->accessBitmap(false);
     44     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
     45     REPORTER_ASSERT(reporter, accessed.pixelRef() == store.pixelRef());
     46 }
     47 
     48 class MockSurface : public SkSurface_Base {
     49 public:
     50     MockSurface(int width, int height) : SkSurface_Base(width, height) {
     51         clearCounts();
     52         fBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
     53         fBitmap.allocPixels();
     54     }
     55 
     56     virtual SkCanvas* onNewCanvas() SK_OVERRIDE {
     57         return SkNEW_ARGS(SkCanvas, (fBitmap));
     58     }
     59 
     60     virtual SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
     61         return NULL;
     62     }
     63 
     64     virtual SkImage* onNewImageSnapshot() SK_OVERRIDE {
     65         return SkNewImageFromBitmap(fBitmap, true);
     66     }
     67 
     68     virtual void onCopyOnWrite(ContentChangeMode mode) SK_OVERRIDE {
     69         if (mode == SkSurface::kDiscard_ContentChangeMode) {
     70             fDiscardCount++;
     71         } else {
     72             fRetainCount++;
     73         }
     74     }
     75 
     76     void clearCounts() {
     77         fDiscardCount = 0;
     78         fRetainCount = 0;
     79     }
     80 
     81     int fDiscardCount, fRetainCount;
     82     SkBitmap fBitmap;
     83 };
     84 
     85 static void TestDeferredCanvasWritePixelsToSurface(skiatest::Reporter* reporter) {
     86     SkAutoTUnref<MockSurface> surface(SkNEW_ARGS(MockSurface, (10, 10)));
     87     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
     88 
     89     SkBitmap srcBitmap;
     90     srcBitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
     91     srcBitmap.allocPixels();
     92     srcBitmap.eraseColor(SK_ColorGREEN);
     93     // Tests below depend on this bitmap being recognized as opaque
     94 
     95     // Preliminary sanity check: no copy on write if no active snapshot
     96     surface->clearCounts();
     97     canvas->clear(SK_ColorWHITE);
     98     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
     99     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    100 
    101     surface->clearCounts();
    102     canvas->flush();
    103     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    104     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    105 
    106     // Case 1: Discard notification happens upon flushing
    107     // with an Image attached.
    108     surface->clearCounts();
    109     SkAutoTUnref<SkImage> image1(canvas->newImageSnapshot());
    110     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    111     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    112 
    113     surface->clearCounts();
    114     canvas->clear(SK_ColorWHITE);
    115     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    116     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    117 
    118     surface->clearCounts();
    119     canvas->flush();
    120     REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
    121     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    122 
    123     // Case 2: Opaque writePixels
    124     surface->clearCounts();
    125     SkAutoTUnref<SkImage> image2(canvas->newImageSnapshot());
    126     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    127     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    128 
    129     surface->clearCounts();
    130     canvas->writePixels(srcBitmap, 0, 0);
    131     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    132     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    133 
    134     surface->clearCounts();
    135     canvas->flush();
    136     REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
    137     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    138 
    139     // Case 3: writePixels that partially covers the canvas
    140     surface->clearCounts();
    141     SkAutoTUnref<SkImage> image3(canvas->newImageSnapshot());
    142     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    143     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    144 
    145     surface->clearCounts();
    146     canvas->writePixels(srcBitmap, 5, 0);
    147     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    148     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    149 
    150     surface->clearCounts();
    151     canvas->flush();
    152     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    153     REPORTER_ASSERT(reporter, 1 == surface->fRetainCount);
    154 
    155     // Case 4: unpremultiplied opaque writePixels that entirely
    156     // covers the canvas
    157     surface->clearCounts();
    158     SkAutoTUnref<SkImage> image4(canvas->newImageSnapshot());
    159     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    160     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    161 
    162     surface->clearCounts();
    163     canvas->writePixels(srcBitmap, 0, 0, SkCanvas::kRGBA_Unpremul_Config8888);
    164     REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
    165     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    166 
    167     surface->clearCounts();
    168     canvas->flush();
    169     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    170     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    171 
    172     // Case 5: unpremultiplied opaque writePixels that partially
    173     // covers the canvas
    174     surface->clearCounts();
    175     SkAutoTUnref<SkImage> image5(canvas->newImageSnapshot());
    176     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    177     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    178 
    179     surface->clearCounts();
    180     canvas->writePixels(srcBitmap, 5, 0, SkCanvas::kRGBA_Unpremul_Config8888);
    181     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    182     REPORTER_ASSERT(reporter, 1 == surface->fRetainCount);
    183 
    184     surface->clearCounts();
    185     canvas->flush();
    186     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    187     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    188 
    189     // Case 6: unpremultiplied opaque writePixels that entirely
    190     // covers the canvas, preceded by clear
    191     surface->clearCounts();
    192     SkAutoTUnref<SkImage> image6(canvas->newImageSnapshot());
    193     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    194     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    195 
    196     surface->clearCounts();
    197     canvas->clear(SK_ColorWHITE);
    198     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    199     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    200 
    201     surface->clearCounts();
    202     canvas->writePixels(srcBitmap, 0, 0, SkCanvas::kRGBA_Unpremul_Config8888);
    203     REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount);
    204     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    205 
    206     surface->clearCounts();
    207     canvas->flush();
    208     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    209     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    210 
    211     // Case 7: unpremultiplied opaque writePixels that partially
    212     // covers the canvas, preceeded by a clear
    213     surface->clearCounts();
    214     SkAutoTUnref<SkImage> image7(canvas->newImageSnapshot());
    215     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    216     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    217 
    218     surface->clearCounts();
    219     canvas->clear(SK_ColorWHITE);
    220     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    221     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    222 
    223     surface->clearCounts();
    224     canvas->writePixels(srcBitmap, 5, 0, SkCanvas::kRGBA_Unpremul_Config8888);
    225     REPORTER_ASSERT(reporter, 1 == surface->fDiscardCount); // because of the clear
    226     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    227 
    228     surface->clearCounts();
    229     canvas->flush();
    230     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    231     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    232 
    233     // Case 8: unpremultiplied opaque writePixels that partially
    234     // covers the canvas, preceeded by a drawREct that partially
    235     // covers the canvas
    236     surface->clearCounts();
    237     SkAutoTUnref<SkImage> image8(canvas->newImageSnapshot());
    238     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    239     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    240 
    241     surface->clearCounts();
    242     SkPaint paint;
    243     canvas->drawRect(SkRect::MakeLTRB(0, 0, 5, 5), paint);
    244     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    245     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    246 
    247     surface->clearCounts();
    248     canvas->writePixels(srcBitmap, 5, 0, SkCanvas::kRGBA_Unpremul_Config8888);
    249     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    250     REPORTER_ASSERT(reporter, 1 == surface->fRetainCount);
    251 
    252     surface->clearCounts();
    253     canvas->flush();
    254     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
    255     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
    256 }
    257 
    258 static void TestDeferredCanvasFlush(skiatest::Reporter* reporter) {
    259     SkBitmap store;
    260 
    261     create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
    262     SkBitmapDevice device(store);
    263     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    264 
    265     canvas->clear(0x00000000);
    266 
    267     SkAutoLockPixels alp(store);
    268     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
    269     canvas->flush();
    270     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
    271 }
    272 
    273 static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
    274     SkBitmap store;
    275     SkRect fullRect;
    276     fullRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(gWidth),
    277         SkIntToScalar(gHeight));
    278     SkRect partialRect;
    279     partialRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0),
    280         SkIntToScalar(1), SkIntToScalar(1));
    281     create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
    282     SkBitmapDevice device(store);
    283     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    284 
    285     // verify that frame is intially fresh
    286     REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    287     // no clearing op since last call to isFreshFrame -> not fresh
    288     REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    289 
    290     // Verify that clear triggers a fresh frame
    291     canvas->clear(0x00000000);
    292     REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    293 
    294     // Verify that clear with saved state triggers a fresh frame
    295     canvas->save(SkCanvas::kMatrixClip_SaveFlag);
    296     canvas->clear(0x00000000);
    297     canvas->restore();
    298     REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    299 
    300     // Verify that clear within a layer does NOT trigger a fresh frame
    301     canvas->saveLayer(NULL, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
    302     canvas->clear(0x00000000);
    303     canvas->restore();
    304     REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    305 
    306     // Verify that a clear with clipping triggers a fresh frame
    307     // (clear is not affected by clipping)
    308     canvas->save(SkCanvas::kMatrixClip_SaveFlag);
    309     canvas->clipRect(partialRect, SkRegion::kIntersect_Op, false);
    310     canvas->clear(0x00000000);
    311     canvas->restore();
    312     REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    313 
    314     // Verify that full frame rects with different forms of opaque paint
    315     // trigger frames to be marked as fresh
    316     {
    317         SkPaint paint;
    318         paint.setStyle(SkPaint::kFill_Style);
    319         paint.setAlpha(255);
    320         canvas->drawRect(fullRect, paint);
    321         REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    322     }
    323     {
    324         SkPaint paint;
    325         paint.setStyle(SkPaint::kFill_Style);
    326         paint.setAlpha(255);
    327         paint.setXfermodeMode(SkXfermode::kSrcIn_Mode);
    328         canvas->drawRect(fullRect, paint);
    329         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    330     }
    331     {
    332         SkPaint paint;
    333         paint.setStyle(SkPaint::kFill_Style);
    334         SkBitmap bmp;
    335         create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
    336         bmp.setAlphaType(kOpaque_SkAlphaType);
    337         SkShader* shader = SkShader::CreateBitmapShader(bmp,
    338             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
    339         paint.setShader(shader)->unref();
    340         canvas->drawRect(fullRect, paint);
    341         REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    342     }
    343 
    344     // Verify that full frame rects with different forms of non-opaque paint
    345     // do not trigger frames to be marked as fresh
    346     {
    347         SkPaint paint;
    348         paint.setStyle(SkPaint::kFill_Style);
    349         paint.setAlpha(254);
    350         canvas->drawRect(fullRect, paint);
    351         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    352     }
    353     {
    354         SkPaint paint;
    355         paint.setStyle(SkPaint::kFill_Style);
    356         // Defining a cone that partially overlaps the canvas
    357         const SkPoint pt1 = SkPoint::Make(SkIntToScalar(0), SkIntToScalar(0));
    358         const SkScalar r1 = SkIntToScalar(1);
    359         const SkPoint pt2 = SkPoint::Make(SkIntToScalar(10), SkIntToScalar(0));
    360         const SkScalar r2 = SkIntToScalar(5);
    361         const SkColor colors[2] = {SK_ColorWHITE, SK_ColorWHITE};
    362         const SkScalar pos[2] = {0, SK_Scalar1};
    363         SkShader* shader = SkGradientShader::CreateTwoPointConical(
    364             pt1, r1, pt2, r2, colors, pos, 2, SkShader::kClamp_TileMode, NULL);
    365         paint.setShader(shader)->unref();
    366         canvas->drawRect(fullRect, paint);
    367         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    368     }
    369     {
    370         SkPaint paint;
    371         paint.setStyle(SkPaint::kFill_Style);
    372         SkBitmap bmp;
    373         create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
    374         bmp.setAlphaType(kPremul_SkAlphaType);
    375         SkShader* shader = SkShader::CreateBitmapShader(bmp,
    376             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
    377         paint.setShader(shader)->unref();
    378         canvas->drawRect(fullRect, paint);
    379         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    380     }
    381 
    382     // Verify that incomplete coverage does not trigger a fresh frame
    383     {
    384         SkPaint paint;
    385         paint.setStyle(SkPaint::kFill_Style);
    386         paint.setAlpha(255);
    387         canvas->drawRect(partialRect, paint);
    388         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    389     }
    390 
    391     // Verify that incomplete coverage due to clipping does not trigger a fresh
    392     // frame
    393     {
    394         canvas->save(SkCanvas::kMatrixClip_SaveFlag);
    395         canvas->clipRect(partialRect, SkRegion::kIntersect_Op, false);
    396         SkPaint paint;
    397         paint.setStyle(SkPaint::kFill_Style);
    398         paint.setAlpha(255);
    399         canvas->drawRect(fullRect, paint);
    400         canvas->restore();
    401         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    402     }
    403     {
    404         canvas->save(SkCanvas::kMatrixClip_SaveFlag);
    405         SkPaint paint;
    406         paint.setStyle(SkPaint::kFill_Style);
    407         paint.setAlpha(255);
    408         SkPath path;
    409         path.addCircle(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(2));
    410         canvas->clipPath(path, SkRegion::kIntersect_Op, false);
    411         canvas->drawRect(fullRect, paint);
    412         canvas->restore();
    413         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    414     }
    415 
    416     // Verify that stroked rect does not trigger a fresh frame
    417     {
    418         SkPaint paint;
    419         paint.setStyle(SkPaint::kStroke_Style);
    420         paint.setAlpha(255);
    421         canvas->drawRect(fullRect, paint);
    422         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
    423     }
    424 
    425     // Verify kSrcMode triggers a fresh frame even with transparent color
    426     {
    427         SkPaint paint;
    428         paint.setStyle(SkPaint::kFill_Style);
    429         paint.setAlpha(100);
    430         paint.setXfermodeMode(SkXfermode::kSrc_Mode);
    431         canvas->drawRect(fullRect, paint);
    432         REPORTER_ASSERT(reporter, canvas->isFreshFrame());
    433     }
    434 }
    435 
    436 class MockDevice : public SkBitmapDevice {
    437 public:
    438     MockDevice(const SkBitmap& bm) : SkBitmapDevice(bm) {
    439         fDrawBitmapCallCount = 0;
    440     }
    441     virtual void drawBitmap(const SkDraw&, const SkBitmap&,
    442                             const SkMatrix&, const SkPaint&) SK_OVERRIDE {
    443         fDrawBitmapCallCount++;
    444     }
    445 
    446     int fDrawBitmapCallCount;
    447 };
    448 
    449 // Verifies that the deferred canvas triggers a flush when its memory
    450 // limit is exceeded
    451 static void TestDeferredCanvasMemoryLimit(skiatest::Reporter* reporter) {
    452     SkBitmap store;
    453     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    454     store.allocPixels();
    455     MockDevice mockDevice(store);
    456     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&mockDevice));
    457     canvas->setMaxRecordingStorage(160000);
    458 
    459     SkBitmap sourceImage;
    460     // 100 by 100 image, takes 40,000 bytes in memory
    461     sourceImage.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    462     sourceImage.allocPixels();
    463 
    464     for (int i = 0; i < 5; i++) {
    465         sourceImage.notifyPixelsChanged(); // to force re-serialization
    466         canvas->drawBitmap(sourceImage, 0, 0, NULL);
    467     }
    468 
    469     REPORTER_ASSERT(reporter, mockDevice.fDrawBitmapCallCount == 4);
    470 }
    471 
    472 class NotificationCounter : public SkDeferredCanvas::NotificationClient {
    473 public:
    474     NotificationCounter() {
    475         fPrepareForDrawCount = fStorageAllocatedChangedCount =
    476             fFlushedDrawCommandsCount = fSkippedPendingDrawCommandsCount = 0;
    477     }
    478 
    479     virtual void prepareForDraw() SK_OVERRIDE {
    480         fPrepareForDrawCount++;
    481     }
    482     virtual void storageAllocatedForRecordingChanged(size_t) SK_OVERRIDE {
    483         fStorageAllocatedChangedCount++;
    484     }
    485     virtual void flushedDrawCommands() SK_OVERRIDE {
    486         fFlushedDrawCommandsCount++;
    487     }
    488     virtual void skippedPendingDrawCommands() SK_OVERRIDE {
    489         fSkippedPendingDrawCommandsCount++;
    490     }
    491 
    492     int fPrepareForDrawCount;
    493     int fStorageAllocatedChangedCount;
    494     int fFlushedDrawCommandsCount;
    495     int fSkippedPendingDrawCommandsCount;
    496 
    497 private:
    498     typedef SkDeferredCanvas::NotificationClient INHERITED;
    499 };
    500 
    501 static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
    502     SkBitmap store;
    503     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    504     store.allocPixels();
    505     SkBitmapDevice device(store);
    506     NotificationCounter notificationCounter;
    507     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    508     canvas->setNotificationClient(&notificationCounter);
    509 
    510     const int imageCount = 2;
    511     SkBitmap sourceImages[imageCount];
    512     for (int i = 0; i < imageCount; i++)
    513     {
    514         sourceImages[i].setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    515         sourceImages[i].allocPixels();
    516     }
    517 
    518     size_t bitmapSize = sourceImages[0].getSize();
    519 
    520     canvas->drawBitmap(sourceImages[0], 0, 0, NULL);
    521     REPORTER_ASSERT(reporter, 1 == notificationCounter.fStorageAllocatedChangedCount);
    522     // stored bitmap + drawBitmap command
    523     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() > bitmapSize);
    524 
    525     // verify that nothing can be freed at this point
    526     REPORTER_ASSERT(reporter, 0 == canvas->freeMemoryIfPossible(~0U));
    527 
    528     // verify that flush leaves image in cache
    529     REPORTER_ASSERT(reporter, 0 == notificationCounter.fFlushedDrawCommandsCount);
    530     REPORTER_ASSERT(reporter, 0 == notificationCounter.fPrepareForDrawCount);
    531     canvas->flush();
    532     REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
    533     REPORTER_ASSERT(reporter, 1 == notificationCounter.fPrepareForDrawCount);
    534     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() >= bitmapSize);
    535 
    536     // verify that after a flush, cached image can be freed
    537     REPORTER_ASSERT(reporter, canvas->freeMemoryIfPossible(~0U) >= bitmapSize);
    538 
    539     // Verify that caching works for avoiding multiple copies of the same bitmap
    540     canvas->drawBitmap(sourceImages[0], 0, 0, NULL);
    541     REPORTER_ASSERT(reporter, 2 == notificationCounter.fStorageAllocatedChangedCount);
    542     canvas->drawBitmap(sourceImages[0], 0, 0, NULL);
    543     REPORTER_ASSERT(reporter, 2 == notificationCounter.fStorageAllocatedChangedCount);
    544     REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
    545     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() < 2 * bitmapSize);
    546 
    547     // Verify partial eviction based on bytesToFree
    548     canvas->drawBitmap(sourceImages[1], 0, 0, NULL);
    549     REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
    550     canvas->flush();
    551     REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
    552     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() > 2 * bitmapSize);
    553     size_t bytesFreed = canvas->freeMemoryIfPossible(1);
    554     REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
    555     REPORTER_ASSERT(reporter,  bytesFreed >= bitmapSize);
    556     REPORTER_ASSERT(reporter,  bytesFreed < 2*bitmapSize);
    557 
    558     // Verifiy that partial purge works, image zero is in cache but not reffed by
    559     // a pending draw, while image 1 is locked-in.
    560     canvas->freeMemoryIfPossible(~0U);
    561     REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
    562     canvas->drawBitmap(sourceImages[0], 0, 0, NULL);
    563     canvas->flush();
    564     canvas->drawBitmap(sourceImages[1], 0, 0, NULL);
    565     bytesFreed = canvas->freeMemoryIfPossible(~0U);
    566     // only one bitmap should have been freed.
    567     REPORTER_ASSERT(reporter,  bytesFreed >= bitmapSize);
    568     REPORTER_ASSERT(reporter,  bytesFreed < 2*bitmapSize);
    569     // Clear for next test
    570     canvas->flush();
    571     canvas->freeMemoryIfPossible(~0U);
    572     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() < bitmapSize);
    573 
    574     // Verify the image cache is sensitive to genID bumps
    575     canvas->drawBitmap(sourceImages[1], 0, 0, NULL);
    576     sourceImages[1].notifyPixelsChanged();
    577     canvas->drawBitmap(sourceImages[1], 0, 0, NULL);
    578     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() > 2*bitmapSize);
    579 
    580     // Verify that nothing in this test caused commands to be skipped
    581     REPORTER_ASSERT(reporter, 0 == notificationCounter.fSkippedPendingDrawCommandsCount);
    582 }
    583 
    584 static void TestDeferredCanvasSkip(skiatest::Reporter* reporter) {
    585     SkBitmap store;
    586     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    587     store.allocPixels();
    588     SkBitmapDevice device(store);
    589     NotificationCounter notificationCounter;
    590     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    591     canvas->setNotificationClient(&notificationCounter);
    592     canvas->clear(0x0);
    593     REPORTER_ASSERT(reporter, 1 == notificationCounter.fSkippedPendingDrawCommandsCount);
    594     REPORTER_ASSERT(reporter, 0 == notificationCounter.fFlushedDrawCommandsCount);
    595     canvas->flush();
    596     REPORTER_ASSERT(reporter, 1 == notificationCounter.fSkippedPendingDrawCommandsCount);
    597     REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
    598 
    599 }
    600 
    601 static void TestDeferredCanvasBitmapShaderNoLeak(skiatest::Reporter* reporter) {
    602     // This is a regression test for crbug.com/155875
    603     // This test covers a code path that inserts bitmaps into the bitmap heap through the
    604     // flattening of SkBitmapProcShaders. The refcount in the bitmap heap is maintained through
    605     // the flattening and unflattening of the shader.
    606     SkBitmap store;
    607     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    608     store.allocPixels();
    609     SkBitmapDevice device(store);
    610     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    611     // test will fail if nbIterations is not in sync with
    612     // BITMAPS_TO_KEEP in SkGPipeWrite.cpp
    613     const int nbIterations = 5;
    614     size_t bytesAllocated = 0;
    615     for(int pass = 0; pass < 2; ++pass) {
    616         for(int i = 0; i < nbIterations; ++i) {
    617             SkPaint paint;
    618             SkBitmap paintPattern;
    619             paintPattern.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
    620             paintPattern.allocPixels();
    621             paint.setShader(SkNEW_ARGS(SkBitmapProcShader,
    622                 (paintPattern, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode)))->unref();
    623             canvas->drawPaint(paint);
    624             canvas->flush();
    625 
    626             // In the first pass, memory allocation should be monotonically increasing as
    627             // the bitmap heap slots fill up.  In the second pass memory allocation should be
    628             // stable as bitmap heap slots get recycled.
    629             size_t newBytesAllocated = canvas->storageAllocatedForRecording();
    630             if (pass == 0) {
    631                 REPORTER_ASSERT(reporter, newBytesAllocated > bytesAllocated);
    632                 bytesAllocated = newBytesAllocated;
    633             } else {
    634                 REPORTER_ASSERT(reporter, newBytesAllocated == bytesAllocated);
    635             }
    636         }
    637     }
    638     // All cached resources should be evictable since last canvas call was flush()
    639     canvas->freeMemoryIfPossible(~0U);
    640     REPORTER_ASSERT(reporter, 0 == canvas->storageAllocatedForRecording());
    641 }
    642 
    643 static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter) {
    644     SkBitmap store;
    645     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    646     store.allocPixels();
    647 
    648     SkBitmap sourceImage;
    649     // 100 by 100 image, takes 40,000 bytes in memory
    650     sourceImage.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    651     sourceImage.allocPixels();
    652 
    653     // 1 under : should not store the image
    654     {
    655         SkBitmapDevice device(store);
    656         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    657         canvas->setBitmapSizeThreshold(39999);
    658         canvas->drawBitmap(sourceImage, 0, 0, NULL);
    659         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
    660         REPORTER_ASSERT(reporter, newBytesAllocated == 0);
    661     }
    662 
    663     // exact value : should store the image
    664     {
    665         SkBitmapDevice device(store);
    666         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    667         canvas->setBitmapSizeThreshold(40000);
    668         canvas->drawBitmap(sourceImage, 0, 0, NULL);
    669         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
    670         REPORTER_ASSERT(reporter, newBytesAllocated > 0);
    671     }
    672 
    673     // 1 over : should still store the image
    674     {
    675         SkBitmapDevice device(store);
    676         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    677         canvas->setBitmapSizeThreshold(40001);
    678         canvas->drawBitmap(sourceImage, 0, 0, NULL);
    679         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
    680         REPORTER_ASSERT(reporter, newBytesAllocated > 0);
    681     }
    682 }
    683 
    684 
    685 typedef void* PixelPtr;
    686 // Returns an opaque pointer which, either points to a GrTexture or RAM pixel
    687 // buffer. Used to test pointer equality do determine whether a surface points
    688 // to the same pixel data storage as before.
    689 static PixelPtr getSurfacePixelPtr(SkSurface* surface, bool useGpu) {
    690     return useGpu ? surface->getCanvas()->getDevice()->accessBitmap(false).getTexture() :
    691         surface->getCanvas()->getDevice()->accessBitmap(false).getPixels();
    692 }
    693 
    694 static void TestDeferredCanvasSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
    695     SkImageInfo imageSpec = {
    696         10,  // width
    697         10,  // height
    698         kPMColor_SkColorType,
    699         kPremul_SkAlphaType
    700     };
    701     SkSurface* surface;
    702     bool useGpu = NULL != factory;
    703 #if SK_SUPPORT_GPU
    704     if (useGpu) {
    705         GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
    706         if (NULL == context) {
    707             return;
    708         }
    709 
    710         surface = SkSurface::NewRenderTarget(context, imageSpec);
    711     } else {
    712         surface = SkSurface::NewRaster(imageSpec);
    713     }
    714 #else
    715     SkASSERT(!useGpu);
    716     surface = SkSurface::NewRaster(imageSpec);
    717 #endif
    718     SkASSERT(NULL != surface);
    719     SkAutoTUnref<SkSurface> aur(surface);
    720     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface));
    721 
    722     SkImage* image1 = canvas->newImageSnapshot();
    723     SkAutoTUnref<SkImage> aur_i1(image1);
    724     PixelPtr pixels1 = getSurfacePixelPtr(surface, useGpu);
    725     // The following clear would normally trigger a copy on write, but
    726     // it won't because rendering is deferred.
    727     canvas->clear(SK_ColorBLACK);
    728     // Obtaining a snapshot directly from the surface (as opposed to the
    729     // SkDeferredCanvas) will not trigger a flush of deferred draw operations
    730     // and will therefore return the same image as the previous snapshot.
    731     SkImage* image2 = surface->newImageSnapshot();
    732     SkAutoTUnref<SkImage> aur_i2(image2);
    733     // Images identical because of deferral
    734     REPORTER_ASSERT(reporter, image1->uniqueID() == image2->uniqueID());
    735     // Now we obtain a snpshot via the deferred canvas, which triggers a flush.
    736     // Because there is a pending clear, this will generate a different image.
    737     SkImage* image3 = canvas->newImageSnapshot();
    738     SkAutoTUnref<SkImage> aur_i3(image3);
    739     REPORTER_ASSERT(reporter, image1->uniqueID() != image3->uniqueID());
    740     // Verify that backing store is now a different buffer because of copy on
    741     // write
    742     PixelPtr pixels2 = getSurfacePixelPtr(surface, useGpu);
    743     REPORTER_ASSERT(reporter, pixels1 != pixels2);
    744     // Verify copy-on write with a draw operation that gets deferred by
    745     // the in order draw buffer.
    746     SkPaint paint;
    747     canvas->drawPaint(paint);
    748     SkImage* image4 = canvas->newImageSnapshot();  // implicit flush
    749     SkAutoTUnref<SkImage> aur_i4(image4);
    750     REPORTER_ASSERT(reporter, image4->uniqueID() != image3->uniqueID());
    751     PixelPtr pixels3 = getSurfacePixelPtr(surface, useGpu);
    752     REPORTER_ASSERT(reporter, pixels2 != pixels3);
    753     // Verify that a direct canvas flush with a pending draw does not trigger
    754     // a copy on write when the surface is not sharing its buffer with an
    755     // SkImage.
    756     canvas->clear(SK_ColorWHITE);
    757     canvas->flush();
    758     PixelPtr pixels4 = getSurfacePixelPtr(surface, useGpu);
    759     canvas->drawPaint(paint);
    760     canvas->flush();
    761     PixelPtr pixels5 = getSurfacePixelPtr(surface, useGpu);
    762     REPORTER_ASSERT(reporter, pixels4 == pixels5);
    763 }
    764 
    765 static void TestDeferredCanvasSetSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
    766     SkImageInfo imageSpec = {
    767         10,  // width
    768         10,  // height
    769         kPMColor_SkColorType,
    770         kPremul_SkAlphaType
    771     };
    772     SkSurface* surface;
    773     SkSurface* alternateSurface;
    774     bool useGpu = NULL != factory;
    775 #if SK_SUPPORT_GPU
    776     if (useGpu) {
    777         GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
    778         if (NULL == context) {
    779             return;
    780         }
    781         surface = SkSurface::NewRenderTarget(context, imageSpec);
    782         alternateSurface = SkSurface::NewRenderTarget(context, imageSpec);
    783     } else {
    784         surface = SkSurface::NewRaster(imageSpec);
    785         alternateSurface = SkSurface::NewRaster(imageSpec);
    786     }
    787 #else
    788     SkASSERT(!useGpu);
    789     surface = SkSurface::NewRaster(imageSpec);
    790     alternateSurface = SkSurface::NewRaster(imageSpec);
    791 #endif
    792     SkASSERT(NULL != surface);
    793     SkASSERT(NULL != alternateSurface);
    794     SkAutoTUnref<SkSurface> aur1(surface);
    795     SkAutoTUnref<SkSurface> aur2(alternateSurface);
    796     PixelPtr pixels1 = getSurfacePixelPtr(surface, useGpu);
    797     PixelPtr pixels2 = getSurfacePixelPtr(alternateSurface, useGpu);
    798     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface));
    799     SkAutoTUnref<SkImage> image1(canvas->newImageSnapshot());
    800     canvas->setSurface(alternateSurface);
    801     SkAutoTUnref<SkImage> image2(canvas->newImageSnapshot());
    802     REPORTER_ASSERT(reporter, image1->uniqueID() != image2->uniqueID());
    803     // Verify that none of the above operations triggered a surface copy on write.
    804     REPORTER_ASSERT(reporter, getSurfacePixelPtr(surface, useGpu) == pixels1);
    805     REPORTER_ASSERT(reporter, getSurfacePixelPtr(alternateSurface, useGpu) == pixels2);
    806     // Verify that a flushed draw command will trigger a copy on write on alternateSurface.
    807     canvas->clear(SK_ColorWHITE);
    808     canvas->flush();
    809     REPORTER_ASSERT(reporter, getSurfacePixelPtr(surface, useGpu) == pixels1);
    810     REPORTER_ASSERT(reporter, getSurfacePixelPtr(alternateSurface, useGpu) != pixels2);
    811 }
    812 
    813 static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
    814     SkBitmap store;
    815     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
    816     store.allocPixels();
    817     SkBitmapDevice device(store);
    818     NotificationCounter notificationCounter;
    819     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
    820     canvas->setNotificationClient(&notificationCounter);
    821     SkAutoTUnref<SkBaseDevice> secondaryDevice(canvas->createCompatibleDevice(
    822         SkBitmap::kARGB_8888_Config, 10, 10, device.isOpaque()));
    823     SkCanvas secondaryCanvas(secondaryDevice.get());
    824     SkRect rect = SkRect::MakeWH(5, 5);
    825     SkPaint paint;
    826     // After spawning a compatible canvas:
    827     // 1) Verify that secondary canvas is usable and does not report to the notification client.
    828     secondaryCanvas.drawRect(rect, paint);
    829     REPORTER_ASSERT(reporter, notificationCounter.fStorageAllocatedChangedCount == 0);
    830     // 2) Verify that original canvas is usable and still reports to the notification client.
    831     canvas->drawRect(rect, paint);
    832     REPORTER_ASSERT(reporter, notificationCounter.fStorageAllocatedChangedCount == 1);
    833 }
    834 
    835 static void TestDeferredCanvas(skiatest::Reporter* reporter, GrContextFactory* factory) {
    836     TestDeferredCanvasBitmapAccess(reporter);
    837     TestDeferredCanvasFlush(reporter);
    838     TestDeferredCanvasFreshFrame(reporter);
    839     TestDeferredCanvasMemoryLimit(reporter);
    840     TestDeferredCanvasBitmapCaching(reporter);
    841     TestDeferredCanvasSkip(reporter);
    842     TestDeferredCanvasBitmapShaderNoLeak(reporter);
    843     TestDeferredCanvasBitmapSizeThreshold(reporter);
    844     TestDeferredCanvasCreateCompatibleDevice(reporter);
    845     TestDeferredCanvasWritePixelsToSurface(reporter);
    846     TestDeferredCanvasSurface(reporter, NULL);
    847     TestDeferredCanvasSetSurface(reporter, NULL);
    848     if (NULL != factory) {
    849         TestDeferredCanvasSurface(reporter, factory);
    850         TestDeferredCanvasSetSurface(reporter, factory);
    851     }
    852 }
    853 
    854 #include "TestClassDef.h"
    855 DEFINE_GPUTESTCLASS("DeferredCanvas", TestDeferredCanvasClass, TestDeferredCanvas)
    856