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"
 
-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.");
+
+
+// Uses dlopen to open the desired library.
+static void* open_library(const char* library) {
+    return dlopen(library, RTLD_LAZY | RTLD_LOCAL);

[djsollen, 2014/07/22 15:06:34]

I expected this function to check the library flag and open the appropriate
library.  It can return 0 both if there was no library and if the library failed
to load, but in the failure case we would log an assert.  If 0 we can just do
the local function.

[scroggo, 2014/07/22 17:10:10]

Done.

+}
+#endif

[djsollen, 2014/07/22 15:06:34]

why #endif followed by identical #ifdef?  Remove both.

[scroggo, 2014/07/22 17:10:10]

Just for future proofing. I can imagine someone adding a new function in
between, not noticing that the code was ifdef'ed out. I'm fine with removing
though.

+
+#ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
+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);
+    void* handle;
+    if (FLAGS_library.count() == 1) {
+        handle = open_library(FLAGS_library[0]);
+        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.

[scroggo, 2014/07/22 17:10:10]

Originally I tried to write this test outside of Skia. It would load two
versions of Skia and use both. That seemed to be messy and unnecessary, but I
think I may have put the wrong calls in the external library. On Android, we
pass an SkCanvas to a newer version of Skia. In order to test that behavior with
this test, we need to build canvas_state_lib with a newer version of Skia, and
then run the test inside the old version of Skia, passing in canvas_state_lib.
Maybe a better way to do this would be to have the library do the creation of
the SkCanvas/SkCanvasState. That way, to automate it, we just need to keep old
versions of canvas_state_lib around. Thoughts?

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

Lets stick with the current version as the other way around gets really messy. 
However document that if you change the SkCanvasState you need to generate the
library with the new content and play it back on the existing code to make sure
everything works.

+                    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);
+    void* handle;
+    if (FLAGS_library.count() == 1) {
+        handle = open_library(FLAGS_library[0]);
+        REPORTER_ASSERT(reporter, handle);
+        if (!handle) {
+            return;
+        }
+        *(void**) (&drawFn) = dlsym(handle, "complex_clips_draw_from_canvas_state");
+    } else {
+        drawFn = 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);
+
+                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);
-}