diff --git a/fpdfsdk/fpdf_view_embeddertest.cpp b/fpdfsdk/fpdf_view_embeddertest.cpp
index 88477ad..098762c 100644
--- a/fpdfsdk/fpdf_view_embeddertest.cpp
+++ b/fpdfsdk/fpdf_view_embeddertest.cpp
@@ -232,16 +232,17 @@
     int width = static_cast<int>(FPDF_GetPageWidth(page));
     int height = static_cast<int>(FPDF_GetPageHeight(page));
 
-    auto recorder = std::make_unique<SkPictureRecorder>();
-    recorder->beginRecording(width, height);
+    sk_sp<SkPicture> picture;
+    {
+      auto recorder = std::make_unique<SkPictureRecorder>();
+      recorder->beginRecording(width, height);
 
-    FPDF_RenderPageSkia(
-        reinterpret_cast<FPDF_SKIA_CANVAS>(recorder->getRecordingCanvas()),
-        page, width, height);
-
-    sk_sp<SkPicture> picture = recorder->finishRecordingAsPicture();
-    recorder.reset();
-    ASSERT_TRUE(picture);
+      FPDF_RenderPageSkia(
+          reinterpret_cast<FPDF_SKIA_CANVAS>(recorder->getRecordingCanvas()),
+          page, width, height);
+      picture = recorder->finishRecordingAsPicture();
+      ASSERT_TRUE(picture);
+    }
 
     ScopedFPDFBitmap bitmap = SkPictureToPdfiumBitmap(
         std::move(picture), SkISize::Make(width, height));
