Add mailbox-based Mojo VideoFrame variant.

media/mojo/clients/mojo_video_decoder.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/mojo/clients/mojo_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 86 matching lines @@
     return;
   }
 
   uint64_t decode_id = decode_counter_++;
   pending_decodes_[decode_id] = decode_cb;
   remote_decoder_->Decode(std::move(mojo_buffer),
                           base::Bind(&MojoVideoDecoder::OnDecodeDone,
                                      base::Unretained(this), decode_id));
 }
 
-void MojoVideoDecoder::OnVideoFrameDecoded(mojom::VideoFramePtr frame) {
+void MojoVideoDecoder::OnVideoFrameDecoded(
+    mojom::VideoFramePtr frame,
+    const OnVideoFrameDecodedCallback& callback) {
   DVLOG(2) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
-  output_cb_.Run(frame.To<scoped_refptr<VideoFrame>>());
+
+  scoped_refptr<VideoFrame> video_frame = frame.To<scoped_refptr<VideoFrame>>();
+  // TODO(sandersd): Fix threading and lifetime of |this|.
+  video_frame->SetReleaseMailboxCB(base::Bind(
+      &MojoVideoDecoder::OnReleaseMailbox, base::Unretained(this), callback));

[sandersd (OOO until July 31), 2017/01/19 19:40:48]

This isn't useful for non-mailbox VideoFrames, but it won't break either.

Option B is to have two different OnVideoFrameDecoded() methods, only one of
which would request destruction callbacks. We would probably want to switch away
from the union type to a different structure for that, so that we can require
mailbox-based VideoFrames for the callback variant.

Option C is to have an OnReleaseMailbox() Mojo method, and not use callbacks at
all. That would require matching frames to callbacks manually, but probably fits
our model better.

Note that the lifetime relationship implies that the callback may not be called
before the connection is torn down. (This supports Option C.)

+  output_cb_.Run(std::move(video_frame));
+}
+
+void MojoVideoDecoder::OnReleaseMailbox(
+    const OnVideoFrameDecodedCallback& callback,
+    const gpu::SyncToken& release_sync_token) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+
+  base::Optional<gpu::SyncToken> token;
+  if (release_sync_token.HasData())
+    token = release_sync_token;
+  callback.Run(std::move(token));
 }
 
 void MojoVideoDecoder::OnDecodeDone(uint64_t decode_id, DecodeStatus status) {
   DVLOG(2) << __func__;
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   auto it = pending_decodes_.find(decode_id);
   if (it == pending_decodes_.end()) {
     DLOG(ERROR) << "Decode request " << decode_id << " not found";
     Stop();
@@ skipping 87 matching lines @@
 
   for (const auto& pending_decode : pending_decodes_)
     pending_decode.second.Run(DecodeStatus::DECODE_ERROR);
   pending_decodes_.clear();
 
   if (!reset_cb_.is_null())
     base::ResetAndReturn(&reset_cb_).Run();
 }
 
 }  // namespace media