Add gpu::MailboxHolder to hold state for a gpu::Mailbox

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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 "content/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 402 matching lines @@
     uint32_t width,
     uint32_t height,
     size_t size) {
   gfx::Rect visible_rect(width, height);
   gfx::Size natural_size(width, height);
   DCHECK(decoder_texture_target_);
   // Convert timestamp from 90KHz to ms.
   base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
       base::checked_numeric_cast<uint64_t>(timestamp) * 1000 / 90);
   return media::VideoFrame::WrapNativeTexture(
-      make_scoped_ptr(new media::VideoFrame::MailboxHolder(
-          pb.texture_mailbox(),
-          0,  // sync_point
-          media::BindToCurrentLoop(
-              base::Bind(&RTCVideoDecoder::ReusePictureBuffer,
-                         weak_this_,
-                         picture.picture_buffer_id())))),
-      decoder_texture_target_,
+      make_scoped_ptr(new gpu::MailboxHolder(
+          pb.texture_mailbox(), decoder_texture_target_, 0)),
+      media::BindToCurrentLoop(base::Bind(&RTCVideoDecoder::ReusePictureBuffer,
+                                          weak_this_,
+                                          picture.picture_buffer_id())),
       pb.size(),
       visible_rect,
       natural_size,
       timestamp_ms,
       base::Bind(&media::GpuVideoAcceleratorFactories::ReadPixels,
                  factories_,
                  pb.texture_id(),
-                 natural_size),
-      base::Closure());
+                 natural_size));
 }
 
 void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
   DCHECK(vda_task_runner_->BelongsToCurrentThread());
 
   std::map<int32, SHMBuffer*>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
@@ skipping 183 matching lines @@
   }
 }
 
 void RTCVideoDecoder::ResetInternal() {
   DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(2) << "ResetInternal";
   if (vda_)
     vda_->Reset();
 }
 
-void RTCVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id,
-                                         uint32 sync_point) {
+void RTCVideoDecoder::ReusePictureBuffer(
+    int64 picture_buffer_id,
+    scoped_ptr<gpu::MailboxHolder> mailbox_holder) {
   DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DVLOG(3) << "ReusePictureBuffer. id=" << picture_buffer_id;
 
   if (!vda_)
     return;
 
   CHECK(!picture_buffers_at_display_.empty());
 
   size_t num_erased = picture_buffers_at_display_.erase(picture_buffer_id);
   DCHECK(num_erased);
 
   std::map<int32, media::PictureBuffer>::iterator it =
       assigned_picture_buffers_.find(picture_buffer_id);
 
   if (it == assigned_picture_buffers_.end()) {
     // This picture was dismissed while in display, so we postponed deletion.
     it = dismissed_picture_buffers_.find(picture_buffer_id);
     DCHECK(it != dismissed_picture_buffers_.end());
     factories_->DeleteTexture(it->second.texture_id());
     dismissed_picture_buffers_.erase(it);
     return;
   }
 
-  factories_->WaitSyncPoint(sync_point);
+  factories_->WaitSyncPoint(mailbox_holder->sync_point);
 
   vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
 void RTCVideoDecoder::DestroyTextures() {
   DCHECK(vda_task_runner_->BelongsToCurrentThread());
   std::map<int32, media::PictureBuffer>::iterator it;
 
   for (it = assigned_picture_buffers_.begin();
        it != assigned_picture_buffers_.end();
@@ skipping 99 matching lines @@
 
 int32_t RTCVideoDecoder::RecordInitDecodeUMA(int32_t status) {
   // Logging boolean is enough to know if HW decoding has been used. Also,
   // InitDecode is less likely to return an error so enum is not used here.
   bool sample = (status == WEBRTC_VIDEO_CODEC_OK) ? true : false;
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
   return status;
 }
 
 }  // namespace content