Run CanvasState test across a library boundary.

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 "SkTemplates.h"
 #include "Test.h"
 
+#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 "
+                           "test SkCanvasState.");
+
+
 static void test_complex_layers(skiatest::Reporter* reporter) {
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
     const int WIDTH = 400;
     const int HEIGHT = 400;
     const int SPACER = 10;
 
     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
     };
     REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
 
+    bool (*drawFn)(SkCanvasState* state, float l, float t,
+                   float r, float b, int32_t s);
+    void* handle;
+    if (FLAGS_library.count() == 1) {
+        handle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
+        REPORTER_ASSERT(reporter, handle);
+        if (!handle) {
+            return;
+        }
+        *(void**) (&drawFn) = dlsym(handle, "complex_layers_draw_from_canvas_state");
+    } else {
+        drawFn = complex_layers_draw_from_canvas_state;
+        handle = NULL;
+    }
+
+    SkAutoTCallIProc<void, dlclose> autoClose(handle);
+    REPORTER_ASSERT(reporter, drawFn);
+    if (!drawFn) {
+        return;
+    }
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(colorTypes); ++i) {
         SkBitmap bitmaps[2];
         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) {
                 // draw a rect within the layer's bounds and again outside the layer's bounds
                 canvas.saveLayerAlpha(&rect, layerAlpha[k], flags[k]);
 
-                SkCanvasState* state = NULL;
-                SkCanvas* tmpCanvas = NULL;
                 if (j) {
-                    state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
+                    // Capture from the first Skia.
+                    SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
                     REPORTER_ASSERT(reporter, state);
-                    tmpCanvas = SkCanvasStateUtils::CreateFromCanvasState(state);
-                    REPORTER_ASSERT(reporter, tmpCanvas);
+
+                    // 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);
+
+                    // And release it in the *first* Skia.
+                    SkCanvasStateUtils::ReleaseCanvasState(state);
                 } else {
-                    tmpCanvas = SkRef(&canvas);
+                    // Draw in the first Skia.
+                    complex_layers_draw(&canvas, rect.fLeft, rect.fTop,
+                                        rect.fRight, rect.fBottom, SPACER);
                 }
 
-                SkPaint bluePaint;
-                bluePaint.setColor(SK_ColorBLUE);
-                bluePaint.setStyle(SkPaint::kFill_Style);
-
-                tmpCanvas->drawRect(rect, bluePaint);
-                tmpCanvas->translate(0, rect.height() + SPACER);
-                tmpCanvas->drawRect(rect, bluePaint);
-
-                tmpCanvas->unref();
-                SkCanvasStateUtils::ReleaseCanvasState(state);
-
                 canvas.restore();
 
                 // translate the canvas for the next iteration
                 canvas.translate(0, 2*(rect.height() + SPACER));
             }
         }
 
         // now we memcmp the two bitmaps
         REPORTER_ASSERT(reporter, bitmaps[0].getSize() == bitmaps[1].getSize());
         REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
@@ skipping 32 matching lines @@
     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,
     };
     REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
 
+    // Will using an SkRegion work at all?
+    bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
+                   int32_t r, int32_t b, int32_t clipOp, const SkRegion*);
+    void* handle;

[djsollen, 2014/07/18 14:11:54]

move this duplicate setup code into a function if possible.

[scroggo, 2014/07/18 19:31:02]

I've moved the call to dlopen into its own function. Do you mean the whole
if/else block? I'm not sure how to factor out the rest, even though the two
callers are similar. I need to return handle, but in the 'if' case it's an error
for it to be null, and in the 'else' it's expected. Also, the two callers of
this function would need to assign functions to function pointers with different
signatures. Is there a clean way to do that?

+    if (FLAGS_library.count() == 1) {
+        handle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
+        REPORTER_ASSERT(reporter, handle);
+        if (!handle) {
+            return;
+        }
+        *(void**) (&drawFn) = dlsym(handle, "test_complex_clips_draw_from_canvas_state");
+    } else {
+        drawFn = test_complex_clips_draw_from_canvas_state;
+        handle = NULL;
+    }
+
+    SkAutoTCallIProc<void, dlclose> autoClose(handle);
+    REPORTER_ASSERT(reporter, drawFn);
+    if (!drawFn) {
+        return;
+    }
+
     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;
 
         for (size_t j = 0; j < SK_ARRAY_COUNT(flags); ++j) {
             SkRect layerBounds = SkRect::Make(layerRect);
             canvas.saveLayerAlpha(&layerBounds, 128, flags[j]);
 
-            SkCanvasState* state = NULL;
-            SkCanvas* tmpCanvas = NULL;
             if (i) {
-                state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
+                SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
                 REPORTER_ASSERT(reporter, state);
-                tmpCanvas = SkCanvasStateUtils::CreateFromCanvasState(state);
-                REPORTER_ASSERT(reporter, tmpCanvas);
+
+                bool success = drawFn(state, clipRect.fLeft, clipRect.fTop,
+                                      clipRect.fRight, clipRect.fBottom, clipOps[j],
+                                      &localRegion);

[scroggo, 2014/07/17 21:32:37]

Note that I'm passing a pointer to an SkRegion across the library boundary. I'd
like to avoid that. (I don't expect SkRegion to change anytime soon, but it
still seems incorrect.) I don't see a good way to decompose it though. I suppose
I could just recreate it from various parameters, though that will be messy.

Thoughts?

[scroggo, 2014/07/18 19:31:02]

Done. Thanks!

+                REPORTER_ASSERT(reporter, success);
+
+                SkCanvasStateUtils::ReleaseCanvasState(state);
             } else {
-                tmpCanvas = SkRef(&canvas);
+                test_complex_clips_draw(&canvas, clipRect.fLeft, clipRect.fTop,
+                                        clipRect.fRight, clipRect.fBottom, clipOps[j],
+                                        localRegion);
             }
 
-            tmpCanvas->save();
-            tmpCanvas->clipRect(SkRect::Make(clipRect), clipOps[j]);
-            tmpCanvas->drawColor(SK_ColorBLUE);
-            tmpCanvas->restore();
-
-            tmpCanvas->clipRegion(localRegion, clipOps[j]);
-            tmpCanvas->drawColor(SK_ColorBLUE);
-
-            tmpCanvas->unref();
-            SkCanvasStateUtils::ReleaseCanvasState(state);
-
             canvas.restore();
 
             // translate the canvas and region for the next iteration
             canvas.translate(0, SkIntToScalar(2*(layerRect.height() + (SPACER))));
             localRegion.translate(0, 2*(layerRect.height() + SPACER));
         }
     }
 
     // now we memcmp the two bitmaps
     REPORTER_ASSERT(reporter, bitmaps[0].getSize() == bitmaps[1].getSize());
@@ skipping 89 matching lines @@
 #endif
 }
 
 DEF_TEST(CanvasState, reporter) {
     test_complex_layers(reporter);
     test_complex_clips(reporter);
     test_draw_filters(reporter);
     test_soft_clips(reporter);
     test_saveLayer_clip(reporter);
 }