replace setConfig+allocPixels with alloc-or-install-pixels

tests/DeferredCanvasTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "../src/image/SkImagePriv.h"
 #include "../src/image/SkSurface_Base.h"
 #include "SkBitmap.h"
 #include "SkBitmapDevice.h"
 #include "SkBitmapProcShader.h"
 #include "SkDeferredCanvas.h"
 #include "SkGradientShader.h"
 #include "SkShader.h"
 #include "SkSurface.h"
 #include "Test.h"
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #else
 class GrContextFactory;
 #endif
 
 static const int gWidth = 2;
 static const int gHeight = 2;
 
-static void create(SkBitmap* bm, SkBitmap::Config config, SkColor color) {
-    bm->setConfig(config, gWidth, gHeight);
-    bm->allocPixels();
+static void create(SkBitmap* bm, SkColor color) {
+    bm->allocN32Pixels(gWidth, gHeight);
     bm->eraseColor(color);
 }
 
 static SkSurface* createSurface(SkColor color) {
     SkSurface* surface = SkSurface::NewRasterPMColor(gWidth, gHeight);
     surface->getCanvas()->clear(color);
     return surface;
 }
 
 static SkPMColor read_pixel(SkSurface* surface, int x, int y) {
@@ skipping 22 matching lines @@
     SkBitmap accessed = canvas->getDevice()->accessBitmap(false);
 
     // verify that clear was executed
     REPORTER_ASSERT(reporter, 0 == read_pixel(surface, 0, 0));
 }
 
 class MockSurface : public SkSurface_Base {
 public:
     MockSurface(int width, int height) : SkSurface_Base(width, height) {
         clearCounts();
-        fBitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
-        fBitmap.allocPixels();
+        fBitmap.allocN32Pixels(width, height);
     }
 
     virtual SkCanvas* onNewCanvas() SK_OVERRIDE {
         return SkNEW_ARGS(SkCanvas, (fBitmap));
     }
 
     virtual SkSurface* onNewSurface(const SkImageInfo&) SK_OVERRIDE {
         return NULL;
     }
 
@@ skipping 16 matching lines @@
 
     int fDiscardCount, fRetainCount;
     SkBitmap fBitmap;
 };
 
 static void TestDeferredCanvasWritePixelsToSurface(skiatest::Reporter* reporter) {
     SkAutoTUnref<MockSurface> surface(SkNEW_ARGS(MockSurface, (10, 10)));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     SkBitmap srcBitmap;
-    srcBitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
-    srcBitmap.allocPixels();
+    srcBitmap.allocN32Pixels(10, 10);
     srcBitmap.eraseColor(SK_ColorGREEN);
     // Tests below depend on this bitmap being recognized as opaque
 
     // Preliminary sanity check: no copy on write if no active snapshot
     surface->clearCounts();
     canvas->clear(SK_ColorWHITE);
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
 
     surface->clearCounts();
@@ skipping 222 matching lines @@
         paint.setStyle(SkPaint::kFill_Style);
         paint.setAlpha(255);
         paint.setXfermodeMode(SkXfermode::kSrcIn_Mode);
         canvas->drawRect(fullRect, paint);
         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
     }
     {
         SkPaint paint;
         paint.setStyle(SkPaint::kFill_Style);
         SkBitmap bmp;
-        create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
+        create(&bmp, 0xFFFFFFFF);
         bmp.setAlphaType(kOpaque_SkAlphaType);
         SkShader* shader = SkShader::CreateBitmapShader(bmp,
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
         paint.setShader(shader)->unref();
         canvas->drawRect(fullRect, paint);
         REPORTER_ASSERT(reporter, canvas->isFreshFrame());
     }
 
     // Verify that full frame rects with different forms of non-opaque paint
     // do not trigger frames to be marked as fresh
@@ skipping 17 matching lines @@
         SkShader* shader = SkGradientShader::CreateTwoPointConical(
             pt1, r1, pt2, r2, colors, pos, 2, SkShader::kClamp_TileMode, NULL);
         paint.setShader(shader)->unref();
         canvas->drawRect(fullRect, paint);
         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
     }
     {
         SkPaint paint;
         paint.setStyle(SkPaint::kFill_Style);
         SkBitmap bmp;
-        create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
+        create(&bmp, 0xFFFFFFFF);
         bmp.setAlphaType(kPremul_SkAlphaType);
         SkShader* shader = SkShader::CreateBitmapShader(bmp,
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
         paint.setShader(shader)->unref();
         canvas->drawRect(fullRect, paint);
         REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
     }
 
     // Verify that incomplete coverage does not trigger a fresh frame
     {
@@ skipping 97 matching lines @@
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
     canvas->setMaxRecordingStorage(160000);
 
     SkBitmap sourceImage;
     // 100 by 100 image, takes 40,000 bytes in memory
-    sourceImage.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    sourceImage.allocPixels();
+    sourceImage.allocN32Pixels(100, 100);
 
     for (int i = 0; i < 5; i++) {
         sourceImage.notifyPixelsChanged(); // to force re-serialization
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
     }
 
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
 }
 
 static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
     const int imageCount = 2;
     SkBitmap sourceImages[imageCount];
-    for (int i = 0; i < imageCount; i++)
-    {
-        sourceImages[i].setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-        sourceImages[i].allocPixels();
+    for (int i = 0; i < imageCount; i++) {
+        sourceImages[i].allocN32Pixels(100, 100);
     }
 
     size_t bitmapSize = sourceImages[0].getSize();
 
     canvas->drawBitmap(sourceImages[0], 0, 0, NULL);
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fStorageAllocatedChangedCount);
     // stored bitmap + drawBitmap command
     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() > bitmapSize);
 
     // verify that nothing can be freed at this point
@@ skipping 78 matching lines @@
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
     // test will fail if nbIterations is not in sync with
     // BITMAPS_TO_KEEP in SkGPipeWrite.cpp
     const int nbIterations = 5;
     size_t bytesAllocated = 0;
     for(int pass = 0; pass < 2; ++pass) {
         for(int i = 0; i < nbIterations; ++i) {
             SkPaint paint;
             SkBitmap paintPattern;
-            paintPattern.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
-            paintPattern.allocPixels();
+            paintPattern.allocN32Pixels(10, 10);
             paint.setShader(SkNEW_ARGS(SkBitmapProcShader,
                 (paintPattern, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode)))->unref();
             canvas->drawPaint(paint);
             canvas->flush();
 
             // In the first pass, memory allocation should be monotonically increasing as
             // the bitmap heap slots fill up.  In the second pass memory allocation should be
             // stable as bitmap heap slots get recycled.
             size_t newBytesAllocated = canvas->storageAllocatedForRecording();
             if (pass == 0) {
                 REPORTER_ASSERT(reporter, newBytesAllocated > bytesAllocated);
                 bytesAllocated = newBytesAllocated;
             } else {
                 REPORTER_ASSERT(reporter, newBytesAllocated == bytesAllocated);
             }
         }
     }
     // All cached resources should be evictable since last canvas call was flush()
     canvas->freeMemoryIfPossible(~0U);
     REPORTER_ASSERT(reporter, 0 == canvas->storageAllocatedForRecording());
 }
 
 static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
 
     SkBitmap sourceImage;
     // 100 by 100 image, takes 40,000 bytes in memory
-    sourceImage.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    sourceImage.allocPixels();
+    sourceImage.allocN32Pixels(100, 100);
 
     // 1 under : should not store the image
     {
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
         canvas->setBitmapSizeThreshold(39999);
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
         REPORTER_ASSERT(reporter, newBytesAllocated == 0);
     }
 
@@ skipping 177 matching lines @@
     TestDeferredCanvasBitmapSizeThreshold(reporter);
     TestDeferredCanvasCreateCompatibleDevice(reporter);
     TestDeferredCanvasWritePixelsToSurface(reporter);
     TestDeferredCanvasSurface(reporter, NULL);
     TestDeferredCanvasSetSurface(reporter, NULL);
     if (NULL != factory) {
         TestDeferredCanvasSurface(reporter, factory);
         TestDeferredCanvasSetSurface(reporter, factory);
     }
 }