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 "Test.h"
 
-static void test_complex_layers(skiatest::Reporter* reporter) {
+// 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 "
+                           "test SkCanvasState.");
+
+
+// This class calls dlopen on the library passed in to the command line flag library, and handles
+// calling dlclose when it goes out of scope.
+class OpenLibResult {
+public:
+    // If the flag library was passed to this run of the test, attempt to open it using dlopen and
+    // report whether it succeeded.
+    OpenLibResult(skiatest::Reporter* reporter) {
+        if (FLAGS_library.count() == 1) {
+            fLibRequired = true;
+            fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
+            REPORTER_ASSERT_MESSAGE(reporter, fHandle != NULL, "Failed to open library!");
+        } else {
+            fLibRequired = false;
+            fHandle = NULL;
+        }
+    }
+
+    // Automatically call dlclose when going out of scope.
+    ~OpenLibResult() {
+        if (fHandle) {
+            dlclose(fHandle);
+        }
+    }
+
+    // Whether the flag library was used.
+    bool libRequired() const {
+        return fLibRequired;
+    }
+
+    // Pointer to the shared library object.
+    void* handle() { return fHandle; }
+
+private:
+    bool fLibRequired;
+    void* fHandle;
+};
+
+DEF_TEST(CanvasState_test_complex_layers, reporter) {
     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);
+
+    OpenLibResult openLibResult(reporter);
+    if (openLibResult.handle() != NULL) {
+        *(void**) (&drawFn) = dlsym(openLibResult.handle(),
+                                    "complex_layers_draw_from_canvas_state");
+    } else {
+        // If the caller intended to open the library, but the library could
+        // not be opened, the rest of the test is not meaningful.
+        if (openLibResult.libRequired()) {

[djsollen, 2014/07/22 17:24:42]

I assumed that in this case we could still test the internal method and not need
to return. That would save you tracking that variable and checking it here, but
I'm fine either way.

[scroggo, 2014/07/22 18:12:01]

Done.

+            return;
+        }
+        drawFn = complex_layers_draw_from_canvas_state;
+    }
+
+    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(),
                                           bitmaps[1].getPixels(),
                                           bitmaps[0].getSize()));
     }
+}
 #endif
-}
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static void test_complex_clips(skiatest::Reporter* reporter) {
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
+DEF_TEST(CanvasState_test_complex_clips, reporter) {
     const int WIDTH = 400;
     const int HEIGHT = 400;
     const int SPACER = 10;
 
     SkIRect layerRect = SkIRect::MakeWH(WIDTH, HEIGHT / 4);
     layerRect.inset(2*SPACER, 2*SPACER);
 
     SkIRect clipRect = layerRect;
     clipRect.fRight = clipRect.fLeft + (clipRect.width() / 2) - (2*SPACER);
     clipRect.outset(SPACER, SPACER);
@@ skipping 12 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));
 
+    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() != NULL) {
+        *(void**) (&drawFn) = dlsym(openLibResult.handle(),
+                                    "complex_clips_draw_from_canvas_state");
+    } else {
+        // If the caller intended to open the library, but the library could
+        // not be opened, the rest of the test is not meaningful.
+        if (openLibResult.libRequired()) {
+            return;
+        }
+        drawFn = complex_clips_draw_from_canvas_state;
+    }
+
+    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);
+
+                SkRegion::Iterator iter(localRegion);
+                SkTDArray<int32_t> rectCoords;
+                for (; !iter.done(); iter.next()) {
+                    const SkIRect& rect = iter.rect();
+                    *rectCoords.append() = rect.fLeft;
+                    *rectCoords.append() = rect.fTop;
+                    *rectCoords.append() = rect.fRight;
+                    *rectCoords.append() = rect.fBottom;
+                }
+                bool success = drawFn(state, clipRect.fLeft, clipRect.fTop,
+                                      clipRect.fRight, clipRect.fBottom, clipOps[j],
+                                      rectCoords.count() / 4, rectCoords.begin());
+                REPORTER_ASSERT(reporter, success);
+
+                SkCanvasStateUtils::ReleaseCanvasState(state);
             } else {
-                tmpCanvas = SkRef(&canvas);
+                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());
     REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
                                       bitmaps[1].getPixels(),
                                       bitmaps[0].getSize()));
+}
 #endif
-}
 
 ////////////////////////////////////////////////////////////////////////////////
 
 class TestDrawFilter : public SkDrawFilter {
 public:
     virtual bool filter(SkPaint*, Type) SK_OVERRIDE { return true; }
 };
 
-static void test_draw_filters(skiatest::Reporter* reporter) {
+DEF_TEST(CanvasState_test_draw_filters, reporter) {
     TestDrawFilter drawFilter;
     SkBitmap bitmap;
     bitmap.allocN32Pixels(10, 10);
     SkCanvas canvas(bitmap);
 
     canvas.setDrawFilter(&drawFilter);
 
     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
     REPORTER_ASSERT(reporter, state);
     SkCanvas* tmpCanvas = SkCanvasStateUtils::CreateFromCanvasState(state);
     REPORTER_ASSERT(reporter, tmpCanvas);
 
     REPORTER_ASSERT(reporter, NULL != canvas.getDrawFilter());
     REPORTER_ASSERT(reporter, NULL == tmpCanvas->getDrawFilter());
 
     tmpCanvas->unref();
     SkCanvasStateUtils::ReleaseCanvasState(state);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // we need this function to prevent SkError from printing to stdout
 static void error_callback(SkError code, void* ctx) {}
 
-static void test_soft_clips(skiatest::Reporter* reporter) {
+DEF_TEST(CanvasState_test_soft_clips, reporter) {
     SkBitmap bitmap;
     bitmap.allocN32Pixels(10, 10);
     SkCanvas canvas(bitmap);
 
     SkRRect roundRect;
     roundRect.setOval(SkRect::MakeWH(5, 5));
 
     canvas.clipRRect(roundRect, SkRegion::kIntersect_Op, true);
 
     SkSetErrorCallback(error_callback, NULL);
 
     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
     REPORTER_ASSERT(reporter, !state);
 
     REPORTER_ASSERT(reporter, kInvalidOperation_SkError == SkGetLastError());
     SkClearLastError();
 }
 
-static void test_saveLayer_clip(skiatest::Reporter* reporter) {
 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
+DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
     const int WIDTH = 100;
     const int HEIGHT = 100;
     const int LAYER_WIDTH = 50;
     const int LAYER_HEIGHT = 50;
 
     SkBitmap bitmap;
     bitmap.allocN32Pixels(WIDTH, HEIGHT);
     SkCanvas canvas(bitmap);
 
     SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
@@ skipping 10 matching lines @@
     canvas.restore();
 
     // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
     // stack to the layer bounds.
     canvas.saveLayer(&bounds, NULL, SkCanvas::kARGB_ClipLayer_SaveFlag);
     canvas.getClipStack()->getBounds(&clipStackBounds, &boundsType);
     REPORTER_ASSERT(reporter, clipStackBounds.width() == LAYER_WIDTH);
     REPORTER_ASSERT(reporter, clipStackBounds.height() == LAYER_HEIGHT);
 
     canvas.restore();
+}
 #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);
-}