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

tests/BlurTest.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 "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkMath.h"
 #include "SkPaint.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #include "SkGpuDevice.h"
 #endif
 
 #define WRITE_CSV 0
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #define ILLEGAL_MODE    ((SkXfermode::Mode)-1)
 
 static const int outset = 100;
 static const SkColor bgColor = SK_ColorWHITE;
 static const int strokeWidth = 4;
 
-static void create(SkBitmap* bm, SkIRect bound, SkBitmap::Config config) {
-    bm->setConfig(config, bound.width(), bound.height());
-    bm->allocPixels();
+static void create(SkBitmap* bm, const SkIRect& bound) {
+    bm->allocN32Pixels(bound.width(), bound.height());
 }
 
 static void drawBG(SkCanvas* canvas) {
     canvas->drawColor(bgColor);
 }
 
 
 struct BlurTest {
     void (*addPath)(SkPath*);
     int viewLen;
@@ skipping 76 matching lines @@
             for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
                 SkPath path;
                 tests[test].addPath(&path);
                 SkPath strokedPath;
                 paint.getFillPath(path, &strokedPath);
                 SkRect refBound = strokedPath.getBounds();
                 SkIRect iref;
                 refBound.roundOut(&iref);
                 iref.inset(-outset, -outset);
                 SkBitmap refBitmap;
-                create(&refBitmap, iref, SkBitmap::kARGB_8888_Config);
+                create(&refBitmap, iref);
 
                 SkCanvas refCanvas(refBitmap);
                 refCanvas.translate(SkIntToScalar(-iref.fLeft),
                                     SkIntToScalar(-iref.fTop));
                 drawBG(&refCanvas);
                 refCanvas.drawPath(path, paint);
 
                 for (int view = 0; view < tests[test].viewLen; ++view) {
                     SkIRect itest = tests[test].views[view];
                     SkBitmap testBitmap;
-                    create(&testBitmap, itest, SkBitmap::kARGB_8888_Config);
+                    create(&testBitmap, itest);
 
                     SkCanvas testCanvas(testBitmap);
                     testCanvas.translate(SkIntToScalar(-itest.fLeft),
                                          SkIntToScalar(-itest.fTop));
                     drawBG(&testCanvas);
                     testCanvas.drawPath(path, paint);
 
                     REPORTER_ASSERT(reporter,
                         compare(refBitmap, iref, testBitmap, itest));
                 }
@@ skipping 86 matching lines @@
                                                     SkBlurMaskFilter::kHighQuality_BlurFlag);
     blurPaint.setMaskFilter(filter)->unref();
 
     canvas->drawColor(SK_ColorBLACK);
     canvas->drawPath(path, blurPaint);
 }
 
 // Readback the blurred draw results from the canvas
 static void readback(SkCanvas* canvas, int* result, int resultCount) {
     SkBitmap readback;
-    readback.setConfig(SkBitmap::kARGB_8888_Config, resultCount, 30);
-    readback.allocPixels();
+    readback.allocN32Pixels(resultCount, 30);
 
     SkIRect readBackRect = { 0, 0, resultCount, 30 };
 
     canvas->readPixels(readBackRect, &readback);
 
     readback.lockPixels();
     SkPMColor* pixels = (SkPMColor*) readback.getAddr32(0, 15);
 
     for (int i = 0; i < resultCount; ++i) {
         result[i] = SkColorGetR(pixels[i]);
     }
 }
 
 // Draw a blurred version of the provided path.
 // Return the right half of the middle row in 'result'.
 static void cpu_blur_path(const SkPath& path, SkScalar gaussianSigma,
                           int* result, int resultCount) {
 
     SkBitmap bitmap;
-    bitmap.setConfig(SkBitmap::kARGB_8888_Config, resultCount, 30);
-    bitmap.allocPixels();
+    bitmap.allocN32Pixels(resultCount, 30);
     SkCanvas canvas(bitmap);
 
     blur_path(&canvas, path, gaussianSigma);
     readback(&canvas, result, resultCount);
 }
 
 #if SK_SUPPORT_GPU
 static bool gpu_blur_path(GrContextFactory* factory, const SkPath& path,
                           SkScalar gaussianSigma,
                           int* result, int resultCount) {
@@ skipping 101 matching lines @@
         write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize);
         write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize);
 #endif
     }
 }
 
 DEF_GPUTEST(Blur, reporter, factory) {
     test_blur_drawing(reporter);
     test_sigma_range(reporter, factory);
 }