Avoid unnecessary post task during frame delivery.

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 <utility>
 
 #include "base/bind.h"
@@ skipping 113 matching lines @@
 static void ReportGpuVideoDecoderInitializeStatusToUMAAndRunCB(
     const VideoDecoder::InitCB& cb,
     bool success) {
   // TODO(xhwang): Report |success| directly.
   PipelineStatus status = success ? PIPELINE_OK : DECODER_ERROR_NOT_SUPPORTED;
   UMA_HISTOGRAM_ENUMERATION(
       "Media.GpuVideoDecoderInitializeStatus", status, PIPELINE_STATUS_MAX + 1);
   cb.Run(success);
 }
 
+// static
+void ReleaseMailboxTrampoline(
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    const VideoFrame::ReleaseMailboxCB& release_mailbox_cb,
+    const gpu::SyncToken& release_sync_token) {
+  if (task_runner->BelongsToCurrentThread()) {
+    release_mailbox_cb.Run(release_sync_token);
+    return;
+  }
+
+  task_runner->PostTask(FROM_HERE,
+                        base::Bind(release_mailbox_cb, release_sync_token));
+}
+
 std::string GpuVideoDecoder::GetDisplayName() const {
   return kDecoderName;
 }
 
 void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  bool /* low_delay */,
                                  CdmContext* cdm_context,
                                  const InitCB& init_cb,
                                  const OutputCB& output_cb) {
   DVLOG(3) << "Initialize()";
@@ skipping 37 matching lines @@
   }
 
   config_ = config;
   needs_all_picture_buffers_to_decode_ =
       capabilities.flags &
       VideoDecodeAccelerator::Capabilities::NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
   supports_deferred_initialization_ = !!(
       capabilities.flags &
       VideoDecodeAccelerator::Capabilities::SUPPORTS_DEFERRED_INITIALIZATION);
-  output_cb_ = BindToCurrentLoop(output_cb);
+  output_cb_ = output_cb;
 
   if (config.is_encrypted() && !supports_deferred_initialization_) {
     DVLOG(1) << __FUNCTION__
              << " Encrypted stream requires deferred initialialization.";
     bound_init_cb.Run(false);
     return;
   }
 
   if (previously_initialized) {
     DVLOG(3) << __FUNCTION__
@@ skipping 342 matching lines @@
 
   VideoPixelFormat pixel_format = vda_->GetOutputFormat();
   if (pixel_format == PIXEL_FORMAT_UNKNOWN) {
     pixel_format =
         IsOpaque(config_.format()) ? PIXEL_FORMAT_XRGB : PIXEL_FORMAT_ARGB;
   }
 
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
       pixel_format, gpu::MailboxHolder(pb.texture_mailbox(0), gpu::SyncToken(),
                                        decoder_texture_target_),
-      BindToCurrentLoop(base::Bind(
-          &GpuVideoDecoder::ReleaseMailbox, weak_factory_.GetWeakPtr(),
-          factories_, picture.picture_buffer_id(), pb.texture_ids())),
+      base::Bind(&ReleaseMailboxTrampoline, factories_->GetTaskRunner(),
+                 base::Bind(&GpuVideoDecoder::ReleaseMailbox,
+                            weak_factory_.GetWeakPtr(), factories_,
+                            picture.picture_buffer_id(), pb.texture_ids())),
       pb.size(), visible_rect, natural_size, timestamp));
   if (!frame) {
     DLOG(ERROR) << "Create frame failed for: " << picture.picture_buffer_id();
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   if (picture.allow_overlay())
     frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
 #if defined(OS_MACOSX) || defined(OS_WIN)
   frame->metadata()->SetBoolean(VideoFrameMetadata::DECODER_OWNS_FRAME, true);
@@ skipping 201 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media