Convert CanvasStateTest to the new saveLayer API

tests/CanvasStateTest.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 "CanvasStateHelpers.h"
 #include "SkCanvas.h"
 #include "SkCanvasStateUtils.h"
 #include "SkCommandLineFlags.h"
 #include "SkDrawFilter.h"
 #include "SkError.h"
 #include "SkPaint.h"
 #include "SkRRect.h"
 #include "SkRect.h"
+#include "SkTLazy.h"
 #include "Test.h"
 
 // dlopen and the library flag are only used for tests which require this flag.
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
 #include <dlfcn.h>
 
 DEFINE_string(library, "", "Support library to use for CanvasState test. If empty (the default), "
                            "the test will be run without crossing a library boundary. Otherwise, "
                            "it is expected to be a full path to a shared library file, which will"
                            " be dynamically loaded. Functions from the library will be called to "
@@ skipping 37 matching lines @@
 
     SkRect rect = SkRect::MakeXYWH(SkIntToScalar(SPACER), SkIntToScalar(SPACER),
                                    SkIntToScalar(WIDTH-(2*SPACER)),
                                    SkIntToScalar((HEIGHT-(2*SPACER)) / 7));
 
     const SkColorType colorTypes[] = {
         kRGB_565_SkColorType, kN32_SkColorType
     };
 
     const int layerAlpha[] = { 255, 255, 0 };
-    const SkCanvas::SaveFlags flags[] = { SkCanvas::kARGB_NoClipLayer_SaveFlag,
-                                          SkCanvas::kARGB_ClipLayer_SaveFlag,
-                                          SkCanvas::kARGB_NoClipLayer_SaveFlag
+    const SkCanvas::SaveLayerFlags flags[] = {
+        static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
+        0,
+        static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
     };
     REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
 
     bool (*drawFn)(SkCanvasState* state, float l, float t,
                    float r, float b, int32_t s);
 
     OpenLibResult openLibResult(reporter);
     if (openLibResult.handle() != nullptr) {
         *(void**) (&drawFn) = dlsym(openLibResult.handle(),
                                     "complex_layers_draw_from_canvas_state");
@@ skipping 11 matching lines @@
         for (int j = 0; j < 2; ++j) {
             bitmaps[j].allocPixels(SkImageInfo::Make(WIDTH, HEIGHT,
                                                      colorTypes[i],
                                                      kPremul_SkAlphaType));
 
             SkCanvas canvas(bitmaps[j]);
 
             canvas.drawColor(SK_ColorRED);
 
             for (size_t k = 0; k < SK_ARRAY_COUNT(layerAlpha); ++k) {
+                SkTLazy<SkPaint> paint;
+                if (layerAlpha[k] != 0xFF) {
+                    paint.init()->setAlpha(layerAlpha[k]);
+                }
+
                 // draw a rect within the layer's bounds and again outside the layer's bounds
-                canvas.saveLayerAlpha(&rect, layerAlpha[k], flags[k]);
+                canvas.saveLayer(SkCanvas::SaveLayerRec(&rect, paint.getMaybeNull(), flags[k]));
 
                 if (j) {
                     // Capture from the first Skia.
                     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
                     REPORTER_ASSERT(reporter, state);
 
                     // And draw to it in the second Skia.
                     bool success = complex_layers_draw_from_canvas_state(state,
                             rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, SPACER);
                     REPORTER_ASSERT(reporter, success);
@@ skipping 45 matching lines @@
 
     SkRegion clipRegion;
     clipRegion.setRect(regionBounds);
     clipRegion.op(regionInterior, SkRegion::kDifference_Op);
 
 
     const SkRegion::Op clipOps[] = { SkRegion::kIntersect_Op,
                                      SkRegion::kIntersect_Op,
                                      SkRegion::kReplace_Op,
     };
-    const SkCanvas::SaveFlags flags[] = { SkCanvas::kARGB_NoClipLayer_SaveFlag,
-                                          SkCanvas::kARGB_ClipLayer_SaveFlag,
-                                          SkCanvas::kARGB_NoClipLayer_SaveFlag,
+    const SkCanvas::SaveLayerFlags flags[] = {
+        static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
+        0,
+        static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
     };
     REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
 
     bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
                    int32_t r, int32_t b, int32_t clipOp,
                    int32_t regionRects, int32_t* rectCoords);
 
     OpenLibResult openLibResult(reporter);
     if (openLibResult.handle() != nullptr) {
         *(void**) (&drawFn) = dlsym(openLibResult.handle(),
@@ skipping 10 matching lines @@
     SkBitmap bitmaps[2];
     for (int i = 0; i < 2; ++i) {
         bitmaps[i].allocN32Pixels(WIDTH, HEIGHT);
 
         SkCanvas canvas(bitmaps[i]);
 
         canvas.drawColor(SK_ColorRED);
 
         SkRegion localRegion = clipRegion;
 
+        SkPaint paint;
+        paint.setAlpha(128);
         for (size_t j = 0; j < SK_ARRAY_COUNT(flags); ++j) {
             SkRect layerBounds = SkRect::Make(layerRect);
-            canvas.saveLayerAlpha(&layerBounds, 128, flags[j]);
+            canvas.saveLayer(SkCanvas::SaveLayerRec(&layerBounds, &paint, flags[j]));
 
             if (i) {
                 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
                 REPORTER_ASSERT(reporter, state);
 
                 SkRegion::Iterator iter(localRegion);
                 SkTDArray<int32_t> rectCoords;
                 for (; !iter.done(); iter.next()) {
                     const SkIRect& rect = iter.rect();
                     *rectCoords.append() = rect.fLeft;
@@ skipping 90 matching lines @@
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(WIDTH, HEIGHT);
     SkCanvas canvas(bitmap);
 
     SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
     canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
 
     // Check that saveLayer without the kClipToLayer_SaveFlag leaves the
     // clip stack unchanged.
-    canvas.saveLayer(&bounds, nullptr, SkCanvas::kARGB_NoClipLayer_SaveFlag);
+    canvas.saveLayer(SkCanvas::SaveLayerRec(&bounds,
+                                            nullptr,
+                                            SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag));
     SkRect clipStackBounds;
     SkClipStack::BoundsType boundsType;
     canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
     // The clip stack will return its bounds, or it may be "full" : i.e. empty + inside_out.
     // Either result is consistent with this test, since the canvas' size is WIDTH/HEIGHT
     if (SkClipStack::kInsideOut_BoundsType == boundsType) {
         REPORTER_ASSERT(reporter, clipStackBounds.isEmpty());
     } else {
         REPORTER_ASSERT(reporter, clipStackBounds.width() == WIDTH);
         REPORTER_ASSERT(reporter, clipStackBounds.height() == HEIGHT);
     }
     canvas.restore();
 
     // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
     // stack to the layer bounds.
-    canvas.saveLayer(&bounds, nullptr, SkCanvas::kARGB_ClipLayer_SaveFlag);
+    canvas.saveLayer(&bounds, nullptr);
     canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
     REPORTER_ASSERT(reporter, clipStackBounds.width() == LAYER_WIDTH);
     REPORTER_ASSERT(reporter, clipStackBounds.height() == LAYER_HEIGHT);
 
     canvas.restore();
 }
 #endif