feat: ctx.addPageAsync()

This appears to be the correct usage of AsyncResource based on docs and
other projects, but AsyncLocalStorage doesn't seem to work (or I'm not
using it correctly). Doesn't really matter, we don't use it.

Author: zbjornson

src/CanvasRenderingContext2d.cc

@@ -100,6 +100,7 @@ Context2d::Initialize(Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target) {
   Nan::SetPrototypeMethod(ctor, "getImageData", GetImageData);
   Nan::SetPrototypeMethod(ctor, "createImageData", CreateImageData);
   Nan::SetPrototypeMethod(ctor, "addPage", AddPage);
+  Nan::SetPrototypeMethod(ctor, "addPageAsync", AddPageAsync);
   Nan::SetPrototypeMethod(ctor, "save", Save);
   Nan::SetPrototypeMethod(ctor, "restore", Restore);
   Nan::SetPrototypeMethod(ctor, "rotate", Rotate);
@@ -746,7 +747,6 @@ NAN_GETTER(Context2d::GetFormat) {
 /*
  * Create a new page.
  */
-
 NAN_METHOD(Context2d::AddPage) {
   Context2d *context = Nan::ObjectWrap::Unwrap<Context2d>(info.This());
   if (context->canvas()->backend()->getName() != "pdf") {
@@ -761,6 +761,59 @@ NAN_METHOD(Context2d::AddPage) {
   return;
 }
 
+struct AddPageInfo {
+  Nan::Callback cb;
+  Context2d* context;
+  Nan::AsyncResource* async;
+  int width;
+  int height;
+};
+
+void AddPageAsyncTask(uv_work_t* req) {
+  AddPageInfo* pi = static_cast<AddPageInfo*>(req->data);
+  cairo_show_page(pi->context->context());
+  cairo_pdf_surface_set_size(pi->context->canvas()->surface(), pi->width, pi->height);
+}
+
+void
+Context2d::AddPageAsyncTaskAfter(uv_work_t* req) {
+  Nan::HandleScope scope;
+  AddPageInfo* pi = static_cast<AddPageInfo*>(req->data);
+  delete req;
+  pi->cb.Call(0, {}, pi->async);
+  pi->context->Unref();
+  delete pi->async;
+  delete pi;
+}
+
+/*
+ * Create a new page asynchronously. When using a PDF surface, Cairo actually
+ * creates a recording surface, then when cairo_show_page() is called, it plays
+ * back the operations *three times*. As such, this can be a very slow function
+ * that benefits from running in a separate thread.
+ */
+NAN_METHOD(Context2d::AddPageAsync) {
+  Context2d *context = Nan::ObjectWrap::Unwrap<Context2d>(info.This());
+  if (context->canvas()->backend()->getName() != "pdf") {
+    return Nan::ThrowError("only PDF canvases support .addPage()");
+  }
+  int width = Nan::To<int32_t>(info[1]).FromMaybe(0);
+  int height = Nan::To<int32_t>(info[2]).FromMaybe(0);
+  if (width < 1) width = context->canvas()->getWidth();
+  if (height < 1) height = context->canvas()->getHeight();
+  AddPageInfo* pi = new AddPageInfo;
+  pi->cb.Reset(info[0].As<Function>());
+  pi->context = context;
+  pi->async = new Nan::AsyncResource("canvas:AddPageAsyncAfter");
+  context->Ref();
+  pi->width = width;
+  pi->height = height;
+  uv_loop_t* loop = uv_default_loop();
+  uv_work_t* req = new uv_work_t;
+  req->data = pi;
+  uv_queue_work(loop, req, AddPageAsyncTask, (uv_after_work_cb)AddPageAsyncTaskAfter);
+}
+
 /*
  * Put image data.
  *

src/CanvasRenderingContext2d.h

@@ -105,6 +105,7 @@ class Context2d : public Nan::ObjectWrap {
     static NAN_METHOD(BeginPath);
     static NAN_METHOD(ClosePath);
     static NAN_METHOD(AddPage);
+    static NAN_METHOD(AddPageAsync);
     static NAN_METHOD(Clip);
     static NAN_METHOD(Fill);
     static NAN_METHOD(Stroke);
@@ -203,6 +204,7 @@ class Context2d : public Nan::ObjectWrap {
     void restore();
     void setFontFromState();
     void resetState();
+    static void AddPageAsyncTaskAfter(uv_work_t* req);
     inline PangoLayout *layout(){ return _layout; }
 
   private:

test/canvas.test.js

@@ -1447,6 +1447,19 @@ describe('Canvas', function () {
     assert.strictEqual(gradient.toString(), '[object CanvasGradient]')
   })
 
+  it('Context2d#addPageAsync()', function (done) {
+    const canvas = createCanvas(200, 200, 'pdf')
+    const ctx = canvas.getContext('2d')
+    ctx.strokeRect(10, 10, 50, 50)
+    ctx.addPageAsync(() => {
+      ctx.strokeRect(20, 20, 50, 50)
+      ctx.addPageAsync(() => {
+        // no crashes, at least
+        done();
+      });
+    })
+  });
+
   describe('Context2d#putImageData()', function () {
     it('throws for invalid arguments', function () {
       const canvas = createCanvas(2, 1)

types/index.d.ts

@@ -193,6 +193,13 @@ export class CanvasRenderingContext2D {
 	 * the canvas's initial size is used.
 	 */
 	addPage(width?: number, height?: number): void
+	/**
+	 * Create a new page asynchronously. When using a PDF surface, Cairo
+	 * actually creates a recording surface, then when cairo_show_page() is
+	 * called, it plays back the operations *three times*. As such, this can be
+	 * a very slow function that benefits from running in a separate thread.
+	 */
+	addPageAsync(width?: number, height?: number): void
 	save(): void;
 	restore(): void;
 	rotate(angle: number): void;