replace setConfig+allocPixels with single call

tests/ImageFilterTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBicubicImageFilter.h"
 #include "SkBitmap.h"
 #include "SkBitmapDevice.h"
@@ skipping 52 matching lines @@
     }
 
 private:
     skiatest::Reporter* fReporter;
     SkMatrix fExpectedMatrix;
 };
 
 }
 
 static void make_small_bitmap(SkBitmap& bitmap) {
-    bitmap.setConfig(SkBitmap::kARGB_8888_Config, kBitmapSize, kBitmapSize);
-    bitmap.allocPixels();
-    SkBitmapDevice device(bitmap);
-    SkCanvas canvas(&device);
+    bitmap.allocN32Pixels(kBitmapSize, kBitmapSize);
+    SkCanvas canvas(bitmap);
     canvas.clear(0x00000000);
     SkPaint darkPaint;
     darkPaint.setColor(0xFF804020);
     SkPaint lightPaint;
     lightPaint.setColor(0xFF244484);
     const int i = kBitmapSize / 4;
     for (int y = 0; y < kBitmapSize; y += i) {
         for (int x = 0; x < kBitmapSize; x += i) {
             canvas.save();
             canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
@@ skipping 65 matching lines @@
         // be expressed as a color filter.
         SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(0, 0, 100, 100));
         SkAutoTUnref<SkImageFilter> grayWithCrop(make_grayscale(NULL, &cropRect));
         REPORTER_ASSERT(reporter, false == grayWithCrop->asColorFilter(NULL));
     }
 
     {
         // Tests pass by not asserting
         SkBitmap bitmap, result;
         make_small_bitmap(bitmap);
-        result.setConfig(SkBitmap::kARGB_8888_Config, kBitmapSize, kBitmapSize);
-        result.allocPixels();
+        result.allocN32Pixels(kBitmapSize, kBitmapSize);
 
         {
             // This tests for :
             // 1 ) location at (0,0,1)
             SkPoint3 location(0, 0, SK_Scalar1);
             // 2 ) location and target at same value
             SkPoint3 target(location.fX, location.fY, location.fZ);
             // 3 ) large negative specular exponent value
             SkScalar specularExponent = -1000;
 
@@ skipping 23 matching lines @@
                             !bicubic->filterImage(&proxy, bitmap, SkMatrix::I(), &result, &loc));
         }
     }
 }
 
 static void test_crop_rects(SkBaseDevice* device, skiatest::Reporter* reporter) {
     // Check that all filters offset to their absolute crop rect,
     // unaffected by the input crop rect.
     // Tests pass by not asserting.
     SkBitmap bitmap;
-    bitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    bitmap.allocPixels();
+    bitmap.allocN32Pixels(100, 100);
     bitmap.eraseARGB(0, 0, 0, 0);
     SkDeviceImageFilterProxy proxy(device);
 
     SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80));
     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60));
     SkAutoTUnref<SkImageFilter> input(make_grayscale(NULL, &inputCropRect));
 
     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
     SkPoint3 location(0, 0, SK_Scalar1);
     SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1);
@@ skipping 34 matching lines @@
         REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, str.c_str());
     }
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
         SkSafeUnref(filters[i]);
     }
 }
 
 DEF_TEST(ImageFilterCropRect, reporter) {
     SkBitmap temp;
-    temp.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    temp.allocPixels();
+    temp.allocN32Pixels(100, 100);
     SkBitmapDevice device(temp);
     test_crop_rects(&device, reporter);
 }
 
 DEF_TEST(ImageFilterMatrixTest, reporter) {
     SkBitmap temp;
-    temp.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    temp.allocPixels();
+    temp.allocN32Pixels(100, 100);
     SkBitmapDevice device(temp);
     SkCanvas canvas(&device);
     canvas.scale(SkIntToScalar(2), SkIntToScalar(2));
 
     SkMatrix expectedMatrix = canvas.getTotalMatrix();
 
     SkPicture picture;
     SkCanvas* recordingCanvas = picture.beginRecording(100, 100,
         SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
 
@@ skipping 16 matching lines @@
     canvas.drawPicture(picture);
 }
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST(ImageFilterCropRectGPU, reporter, factory) {
     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
     SkGpuDevice device(context, SkBitmap::kARGB_8888_Config, 100, 100);
     test_crop_rects(&device, reporter);
 }
 #endif