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

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
+#include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_log.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder_config.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
 
 namespace media {
 
@@ skipping 409 matching lines @@
 
   // Update frame's timestamp.
   base::TimeDelta timestamp;
   gfx::Rect visible_rect;
   gfx::Size natural_size;
   GetBufferData(picture.bitstream_buffer_id(), &timestamp, &visible_rect,
                 &natural_size);
   DCHECK(decoder_texture_target_);
 
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
-      make_scoped_ptr(new VideoFrame::MailboxHolder(
-          pb.texture_mailbox(),
-          0,  // sync_point
-          BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReusePictureBuffer,
-                                       weak_this_,
-                                       picture.picture_buffer_id())))),
-      decoder_texture_target_,
+      make_scoped_ptr(new gpu::MailboxHolder(
+          pb.texture_mailbox(), decoder_texture_target_, 0 /* sync_point */)),
+      BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReusePictureBuffer,
+                                   weak_this_,
+                                   picture.picture_buffer_id())),
       pb.size(),
       visible_rect,
       natural_size,
       timestamp,
       base::Bind(&GpuVideoAcceleratorFactories::ReadPixels,
                  factories_,
                  pb.texture_id(),
-                 gfx::Size(visible_rect.width(), visible_rect.height())),
-      base::Closure()));
+                 gfx::Size(visible_rect.width(), visible_rect.height()))));
   CHECK_GT(available_pictures_, 0);
   --available_pictures_;
   bool inserted =
       picture_buffers_at_display_.insert(picture.picture_buffer_id()).second;
   DCHECK(inserted);
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
@@ skipping 11 matching lines @@
     DCHECK(!ready_video_frames_.empty());
 
   if (pending_decode_cb_.is_null())
     return;
 
   base::ResetAndReturn(&pending_decode_cb_)
       .Run(kOk, ready_video_frames_.front());
   ready_video_frames_.pop_front();
 }
 
-void GpuVideoDecoder::ReusePictureBuffer(int64 picture_buffer_id,
-                                         uint32 sync_point) {
+void GpuVideoDecoder::ReusePictureBuffer(
+    int64 picture_buffer_id,
+    scoped_ptr<gpu::MailboxHolder> mailbox_holder) {
   DVLOG(3) << "ReusePictureBuffer(" << picture_buffer_id << ")";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (!vda_)
     return;
 
   CHECK(!picture_buffers_at_display_.empty());
 
   size_t num_erased = picture_buffers_at_display_.erase(picture_buffer_id);
   DCHECK(num_erased);
 
   PictureBufferMap::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);
   ++available_pictures_;
 
   vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
 GpuVideoDecoder::SHMBuffer* GpuVideoDecoder::GetSHM(size_t min_size) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (available_shm_segments_.empty() ||
       available_shm_segments_.back()->size < min_size) {
     size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
@@ skipping 93 matching lines @@
     return;
   }
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media