Stack overflow when deallocating PictureRecorder

[samizdatco]

While investigating this issue reporting silent crashes during image exports I’ve come across a reproducible stack overflow when a PictureRecorder goes out of scope.

The example code below is a little contrived but mirrors the way I’m attempting to make PictureRecorder ‘restartable’, such that a picture can be generated and then additional drawing commands can be appended to it. My approach has been to start a new recording and immediately draw the output Picture to it, then start directing client commands to that new recording.

When Pictures are generated repeatedly, there are increasing levels of nesting, since each ‘restart’ of the PictureRecorder draws the Picture of its previous state (which in turn draws the Picture of its previous state, and so on). Note that It’s quite possible that this is an anti-pattern that I should abandon and if so would love suggestions for alternative approaches.

Here’s a test case that reliably triggers a stack overflow for me (though it wouldn’t surprise me if you need to adjust the loop range above 20k on other systems):

fn recorder_test() {
  use skia_safe::{Rect, PictureRecorder, Paint};
  let paint = Paint::default();
  let bounds = Rect::from_wh(10.0, 10.0);

  {
    let mut rec = PictureRecorder::new();
    rec.begin_recording(bounds, None);

    for _ in 1..20_000{
      let snapshot = rec.finish_recording_as_picture(Some(&bounds)).unwrap();
      rec.begin_recording(bounds, None);

      let canvas = rec.recording_canvas().unwrap();
      canvas.draw_picture(&snapshot, None, None);
      canvas.draw_point((5.0,5.0), &paint);

      println!("{:?}", snapshot);
    }

    println!("will dealloc recorder...")
    // > thread 'tests::recorder_test' has overflowed its stack
    // > fatal runtime error: stack overflow
  }

  println!("done."); // never reached
}

And just to demonstrate that it’s related to the nested Picture drawing and not simply the number of drawing operations, this runs with no problem:

  fn many_dots_test() {
    use skia_safe::{Rect, PictureRecorder, Paint};
    let paint = Paint::default();
    let bounds = Rect::from_wh(10.0, 10.0);

    {
      let mut rec = PictureRecorder::new();
      rec.begin_recording(bounds, None);

      for _ in 1..900_000{
        let canvas = rec.recording_canvas().unwrap();
        canvas.draw_point((5.0,5.0), &paint);
      }

      let snapshot = rec.finish_recording_as_picture(Some(&bounds)).unwrap();
      println!("{:?}", snapshot);

      println!("will dealloc recorder...")
    }

    println!("done.");
  }