media/gpu/test: Fixed missing frames in video decoder tests in allocate mode.

When running the new video decoder tests in allocate mode, sometimes the video
player will not receive the last frame, making the tests fails. This happens
because the WrapVideoFrame method is only supported in import mode, and a
workaround is used in allocate mode.

To fix this issue logic is added to manually wrap frames in a similar way when
using allocate mode. This is also required to run the video decoder performance
tests on allocate-only platforms.

TEST=./video_decode_accelerator_tests on nyan_big

BUG=957808

Change-Id: Ibf29e9f716beef8aaf1a27904e2220399418c209
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1688773
Commit-Queue: David Staessens <dstaessens@chromium.org>
Reviewed-by: Hirokazu Honda <hiroh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#676259}

media/gpu/test/video_player/test_vda_video_decoder.cc

@@ -280,33 +280,33 @@ void TestVDAVideoDecoder::PictureReady(const Picture& picture) {
   ASSERT_NE(timestamp_it, decode_start_timestamps_.end());
   video_frame->set_timestamp(timestamp_it->second);
 
-  // When using import mode, we wrap the video frame in another video frame that
-  // calls ReusePictureBufferTask() upon destruction. When the renderer and
-  // video frame processors are done using the video frame, the associated
-  // picture buffer will automatically be flagged for reuse.
-  if (output_mode_ == VideoDecodeAccelerator::Config::OutputMode::IMPORT) {
-    base::OnceClosure reuse_cb = BindToCurrentLoop(
-        base::BindOnce(&TestVDAVideoDecoder::ReusePictureBufferTask, weak_this_,
-                       picture.picture_buffer_id()));
-
-    scoped_refptr<VideoFrame> wrapped_video_frame = VideoFrame::WrapVideoFrame(
+  scoped_refptr<VideoFrame> wrapped_video_frame = nullptr;
+
+  // Wrap the video frame in another frame that calls ReusePictureBufferTask()
+  // upon destruction. When the renderer and video frame processors are done
+  // using the video frame, the associated picture buffer will automatically be
+  // flagged for reuse. WrapVideoFrame() is not supported for texture-based
+  // video frames (see http://crbug/362521) so we work around this by creating a
+  // new video frame using the same mailbox.
+  if (!video_frame->HasTextures()) {
+    wrapped_video_frame = VideoFrame::WrapVideoFrame(
         *video_frame, video_frame->format(), picture.visible_rect(),
         picture.visible_rect().size());
-    wrapped_video_frame->AddDestructionObserver(std::move(reuse_cb));
-
-    output_cb_.Run(wrapped_video_frame);
+  } else {
+    gpu::MailboxHolder mailbox_holders[media::VideoFrame::kMaxPlanes];
+    mailbox_holders[0] = video_frame->mailbox_holder(0);
+    wrapped_video_frame = VideoFrame::WrapNativeTextures(
+        video_frame->format(), mailbox_holders, VideoFrame::ReleaseMailboxCB(),
+        video_frame->coded_size(), video_frame->visible_rect(),
+        video_frame->natural_size(), video_frame->timestamp());
   }
 
-  // Wrapping a video frame inside another video frame is not supported in
-  // allocate mode, so we have to render the frame and return the picture buffer
-  // synchronously here. See http://crbug/362521.
-  if (output_mode_ == VideoDecodeAccelerator::Config::OutputMode::ALLOCATE) {
-    PostTaskAndReply(
-        FROM_HERE, base::BindOnce(output_cb_, video_frame),
-        base::BindOnce(&TestVDAVideoDecoder::ReusePictureBufferTask, weak_this_,
-                       picture.picture_buffer_id()));
-    return;
-  }
+  DCHECK(wrapped_video_frame);
+  base::OnceClosure reuse_cb = BindToCurrentLoop(
+      base::BindOnce(&TestVDAVideoDecoder::ReusePictureBufferTask, weak_this_,
+                     picture.picture_buffer_id()));
+  wrapped_video_frame->AddDestructionObserver(std::move(reuse_cb));
+  output_cb_.Run(std::move(wrapped_video_frame));
 }
 
 // Called when a picture buffer is ready to be re-used.

media/gpu/test/video_player/video_decoder_client.cc

@@ -337,8 +337,6 @@ void VideoDecoderClient::DecodeDoneTask(media::DecodeStatus status) {
 void VideoDecoderClient::FrameReadyTask(scoped_refptr<VideoFrame> video_frame) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(decoder_client_sequence_checker_);
 
-  // When using allocate mode the frame will be reused after this function, so
-  // the frame should be rendered synchronously in this case.
   frame_renderer_->RenderFrame(video_frame);
 
   // When using allocate mode, direct texture memory access is not supported.