media/gpu/vaapi/VaapiDmabufVFMapper: Make a mapped frame outlive a source video frame

A VideoFrame mapped by the VaapiDmabufVideoFrameMapper holds a VAImage created
from the source VideoFrame. The VA surface associated the source video frame
should not be released until the mapped video frame is destroyed, so we bind a
reference to the source video frame to the mapped video frame's destructor.

Bug: 1020776
Test: VD test on atlas
Change-Id: Ia0b01b4bcb3e4312c0c2e91f8ad8c8beae20f393
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1911342
Commit-Queue: Hirokazu Honda <hiroh@chromium.org>
Reviewed-by: David Staessens <dstaessens@chromium.org>
Cr-Commit-Position: refs/heads/master@{#714807}

media/gpu/vaapi/vaapi_dmabuf_video_frame_mapper.cc

@@ -22,15 +22,17 @@ constexpr VAImageFormat kImageFormatNV12{.fourcc = VA_FOURCC_NV12,
                                          .byte_order = VA_LSB_FIRST,
                                          .bits_per_pixel = 12};
 
-void DeallocateBuffers(std::unique_ptr<ScopedVAImage> va_image) {
+void DeallocateBuffers(std::unique_ptr<ScopedVAImage> va_image,
+                       scoped_refptr<const VideoFrame> /* video_frame */) {
+  // The |video_frame| will be released here and it will be returned to pool if
+  // client uses video frame pool.
   // Destructing ScopedVAImage releases its owned memory.
   DCHECK(va_image->IsValid());
 }
 
 scoped_refptr<VideoFrame> CreateMappedVideoFrame(
     const VideoPixelFormat format,
-    const gfx::Rect& visible_rect,
-    const base::TimeDelta timestamp,
+    scoped_refptr<const VideoFrame> src_video_frame,
     std::unique_ptr<ScopedVAImage> va_image) {
   DCHECK(va_image);
   // ScopedVAImage manages the resource of mapped data. That is, ScopedVAImage's
@@ -71,13 +73,16 @@ scoped_refptr<VideoFrame> CreateMappedVideoFrame(
     return nullptr;
   }
   auto video_frame = VideoFrame::WrapExternalYuvDataWithLayout(
-      *mapped_layout, visible_rect, visible_rect.size(), addrs[0], addrs[1],
-      addrs[2], timestamp);
+      *mapped_layout, src_video_frame->visible_rect(),
+      src_video_frame->visible_rect().size(), addrs[0], addrs[1], addrs[2],
+      src_video_frame->timestamp());
   if (!video_frame)
     return nullptr;
 
-  video_frame->AddDestructionObserver(
-      base::BindOnce(DeallocateBuffers, std::move(va_image)));
+  // The source video frame should not be released until the mapped
+  // |video_frame| is destructed, because |video_frame| holds |va_image|.
+  video_frame->AddDestructionObserver(base::BindOnce(
+      DeallocateBuffers, std::move(va_image), std::move(src_video_frame)));
   return video_frame;
 }
 
@@ -150,8 +155,8 @@ scoped_refptr<VideoFrame> VaapiDmaBufVideoFrameMapper::Map(
     return nullptr;
   }
 
-  return CreateMappedVideoFrame(kConvertedFormat, video_frame->visible_rect(),
-                                video_frame->timestamp(), std::move(va_image));
+  return CreateMappedVideoFrame(kConvertedFormat, std::move(video_frame),
+                                std::move(va_image));
 }
 
 }  // namespace media