Remove DEPRECATED_beginRecording().

tests/PictureTest.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 "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
@@ skipping 561 matching lines @@
                 if (!found) {
                     SkData* data = SkPictureUtils::GatherPixelRefs(pic, r);
                     size_t dataSize = data ? data->size() : 0;
                 }
 #endif
             }
         }
     }
 }
 
-#define GENERATE_CANVAS(recorder, x) \
-    (x) ? recorder.EXPERIMENTAL_beginRecording(100, 100) \
-        : recorder.  DEPRECATED_beginRecording(100,100);
-
 /* Hit a few SkPicture::Analysis cases not handled elsewhere. */
-static void test_analysis(skiatest::Reporter* reporter, bool useNewPath) {
+static void test_analysis(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
-    SkCanvas* canvas = GENERATE_CANVAS(recorder, useNewPath);
+    SkCanvas* canvas = recorder.beginRecording(100, 100);
     {
         canvas->drawRect(SkRect::MakeWH(10, 10), SkPaint ());
     }
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     REPORTER_ASSERT(reporter, !picture->willPlayBackBitmaps());
 
-    canvas = GENERATE_CANVAS(recorder, useNewPath);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         // CreateBitmapShader is too smart for us; an empty (or 1x1) bitmap shader
         // gets optimized into a non-bitmap form, so we create a 2x2 bitmap here.
         SkBitmap bitmap;
         bitmap.allocPixels(SkImageInfo::MakeN32Premul(2, 2));
         bitmap.eraseColor(SK_ColorBLUE);
         *(bitmap.getAddr32(0, 0)) = SK_ColorGREEN;
         SkShader* shader = SkShader::CreateBitmapShader(bitmap, SkShader::kClamp_TileMode,
                                                         SkShader::kClamp_TileMode);
@@ skipping 130 matching lines @@
 //        SkDebugf("clip\n");
         canvas->clipRect(rect);
     } else {
 //        SkDebugf("draw\n");
         canvas->drawPaint(paint);
     }
 }
 
 #if SK_SUPPORT_GPU
 
-static void test_gpu_veto(skiatest::Reporter* reporter,
-                          bool useNewPath) {
-
+static void test_gpu_veto(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
-    SkCanvas* canvas = GENERATE_CANVAS(recorder, useNewPath);
+    SkCanvas* canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         SkScalar intervals[] = { 1.0f, 1.0f };
         SkAutoTUnref<SkDashPathEffect> dash(SkDashPathEffect::Create(intervals, 2, 0));
 
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setPathEffect(dash);
 
         canvas->drawPath(path, paint);
     }
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     // path effects currently render an SkPicture undesireable for GPU rendering
 
     const char *reason = NULL;
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL, &reason));
     REPORTER_ASSERT(reporter, reason);
 
-    canvas = GENERATE_CANVAS(recorder, useNewPath);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // A lot of AA concave paths currently render an SkPicture undesireable for GPU rendering
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
 
-    canvas = GENERATE_CANVAS(recorder, useNewPath);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPath path;
 
         path.moveTo(0, 0);
         path.lineTo(0, 50);
         path.lineTo(25, 25);
         path.lineTo(50, 50);
         path.lineTo(50, 0);
         path.close();
         REPORTER_ASSERT(reporter, !path.isConvex());
 
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(0);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // hairline stroked AA concave paths are fine for GPU rendering
     REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL));
 
-    canvas = GENERATE_CANVAS(recorder, useNewPath);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25);
         paint.setPathEffect(pe)->unref();
 
         SkPoint points [2] = { { 0, 0 }, { 100, 0 } };
         canvas->drawPoints(SkCanvas::kLines_PointMode, 2, points, paint);
     }
     picture.reset(recorder.endRecording());
     // fast-path dashed effects are fine for GPU rendering ...
     REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL));
 
-    canvas = GENERATE_CANVAS(recorder, useNewPath);
+    canvas = recorder.beginRecording(100, 100);
     {
         SkPaint paint;
         SkScalar intervals [] = { 10, 20 };
         SkPathEffect* pe = SkDashPathEffect::Create(intervals, 2, 25);
         paint.setPathEffect(pe)->unref();
 
         canvas->drawRect(SkRect::MakeWH(10, 10), paint);
     }
     picture.reset(recorder.endRecording());
     // ... but only when applied to drawPoint() calls
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
 
     // Nest the previous picture inside a new one.
-    // This doesn't work in the old backend.
-    if (useNewPath) {
-        canvas = GENERATE_CANVAS(recorder, useNewPath);
-        {
-            canvas->drawPicture(picture.get());
-        }
-        picture.reset(recorder.endRecording());
-        REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
+    canvas = recorder.beginRecording(100, 100);
+    {
+        canvas->drawPicture(picture.get());
     }
+    picture.reset(recorder.endRecording());
+    REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
 }
 
-#undef GENERATE_CANVAS
-
 static void test_gpu_picture_optimization(skiatest::Reporter* reporter,
                                           GrContextFactory* factory) {
     for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
         GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
 
         if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
             continue;
         }
 
         GrContext* context = factory->get(glCtxType);
@@ skipping 193 matching lines @@
             REPORTER_ASSERT(reporter, 0 == info7.fOffset.fX && 0 == info7.fOffset.fY);
             REPORTER_ASSERT(reporter, info7.fOriginXform.isIdentity());
             REPORTER_ASSERT(reporter, NULL == info7.fPaint);
             REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested
         }
     }
 }
 
 #endif
 
-static void test_has_text(skiatest::Reporter* reporter, bool useNewPath) {
+static void test_has_text(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
-#define BEGIN_RECORDING useNewPath ? recorder.EXPERIMENTAL_beginRecording(100, 100) \
-                                   : recorder.  DEPRECATED_beginRecording(100, 100)
 
-    SkCanvas* canvas = BEGIN_RECORDING;
+    SkCanvas* canvas = recorder.beginRecording(100,100);
     {
         canvas->drawRect(SkRect::MakeWH(20, 20), SkPaint());
     }
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     REPORTER_ASSERT(reporter, !picture->hasText());
 
     SkPoint point = SkPoint::Make(10, 10);
-    canvas = BEGIN_RECORDING;
+    canvas = recorder.beginRecording(100,100);
     {
         canvas->drawText("Q", 1, point.fX, point.fY, SkPaint());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
-    canvas = BEGIN_RECORDING;
+    canvas = recorder.beginRecording(100,100);
     {
         canvas->drawPosText("Q", 1, &point, SkPaint());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
-    canvas = BEGIN_RECORDING;
+    canvas = recorder.beginRecording(100,100);
     {
         canvas->drawPosTextH("Q", 1, &point.fX, point.fY, SkPaint());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
-    canvas = BEGIN_RECORDING;
+    canvas = recorder.beginRecording(100,100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         canvas->drawTextOnPathHV("Q", 1, path, point.fX, point.fY, SkPaint());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
-    canvas = BEGIN_RECORDING;
+    canvas = recorder.beginRecording(100,100);
     {
         SkPath path;
         path.moveTo(0, 0);
         path.lineTo(50, 50);
 
         canvas->drawTextOnPath("Q", 1, path, NULL, SkPaint());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, picture->hasText());
 
     // Nest the previous picture inside a new one.
-    // This doesn't work in the old backend.
-    if (useNewPath) {
-        canvas = BEGIN_RECORDING;
-        {
-            canvas->drawPicture(picture.get());
-        }
-        picture.reset(recorder.endRecording());
-        REPORTER_ASSERT(reporter, picture->hasText());
+    canvas = recorder.beginRecording(100,100);
+    {
+        canvas->drawPicture(picture.get());
     }
-#undef BEGIN_RECORDING
+    picture.reset(recorder.endRecording());
+    REPORTER_ASSERT(reporter, picture->hasText());
 }
 
 static void set_canvas_to_save_count_4(SkCanvas* canvas) {
     canvas->restoreToCount(1);
     canvas->save();
     canvas->save();
     canvas->save();
 }
 
 /**
@@ skipping 616 matching lines @@
 DEF_TEST(Picture, reporter) {
 #ifdef SK_DEBUG
     test_deleting_empty_picture();
     test_serializing_empty_picture();
 #else
     test_bad_bitmap();
 #endif
     test_unbalanced_save_restores(reporter);
     test_peephole();
 #if SK_SUPPORT_GPU
-    test_gpu_veto(reporter, false);
-    test_gpu_veto(reporter, true);
+    test_gpu_veto(reporter);
 #endif
-    test_has_text(reporter, false);
-    test_has_text(reporter, true);
-    test_analysis(reporter, false);
-    test_analysis(reporter, true);
+    test_has_text(reporter);
+    test_analysis(reporter);
     test_gatherpixelrefs(reporter);
     test_gatherpixelrefsandrects(reporter);
     test_bitmap_with_encoded_data(reporter);
     test_draw_empty(reporter);
     test_clip_bound_opt(reporter);
     test_clip_expansion(reporter);
     test_hierarchical(reporter);
     test_gen_id(reporter);
 }
 
@@ skipping 151 matching lines @@
 
     // The picture shares the immutable pixels but copies the mutable ones.
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, !immut.pixelRef()->unique());
 
     // When the picture goes away, it's just our bitmaps holding the refs.
     pic.reset(NULL);
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, immut.pixelRef()->unique());
 }