Cast: deliver video frames on the IO thread

content/renderer/pepper/pepper_media_stream_video_track_host.cc

 // Copyright 2014 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/pepper/pepper_media_stream_video_track_host.h"
 
 #include "base/base64.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_video_track.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/base/yuv_convert.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_media_stream_video_track.h"
 #include "ppapi/c/ppb_video_frame.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/media_stream_buffer.h"
 
 // IS_ALIGNED is also defined in
@@ skipping 211 matching lines @@
     PP_Resource resource,
     const blink::WebMediaStreamTrack& track)
     : PepperMediaStreamTrackHostBase(host, instance, resource),
       track_(track),
       connected_(false),
       number_of_buffers_(kDefaultNumberOfBuffers),
       source_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       plugin_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       frame_data_size_(0),
       type_(kRead),
-      output_started_(false) {
+      output_started_(false),
+      weak_factory_(this) {
   DCHECK(!track_.isNull());
 }
 
 PepperMediaStreamVideoTrackHost::PepperMediaStreamVideoTrackHost(
     RendererPpapiHost* host,
     PP_Instance instance,
     PP_Resource resource)
     : PepperMediaStreamTrackHostBase(host, instance, resource),
       connected_(false),
       number_of_buffers_(kDefaultNumberOfBuffers),
       source_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       plugin_frame_format_(PP_VIDEOFRAME_FORMAT_UNKNOWN),
       frame_data_size_(0),
       type_(kWrite),
-      output_started_(false) {
+      output_started_(false),
+      weak_factory_(this) {
   InitBlinkTrack();
   DCHECK(!track_.isNull());
 }
 
 bool PepperMediaStreamVideoTrackHost::IsMediaStreamVideoTrackHost() {
   return true;
 }
 
 PepperMediaStreamVideoTrackHost::~PepperMediaStreamVideoTrackHost() {
   OnClose();
@@ skipping 36 matching lines @@
 
     // Make all the frames avaiable to the plugin.
     std::vector<int32_t> indices = buffer_manager()->DequeueBuffers();
     SendEnqueueBuffersMessageToPlugin(indices);
   }
 }
 
 void PepperMediaStreamVideoTrackHost::OnClose() {
   if (connected_) {
     MediaStreamVideoSink::RemoveFromVideoTrack(this, track_);
+    weak_factory_.InvalidateWeakPtrs();
     connected_ = false;
   }
 }
 
 int32_t PepperMediaStreamVideoTrackHost::OnHostMsgEnqueueBuffer(
     ppapi::host::HostMessageContext* context, int32_t index) {
   if (type_ == kRead) {
     return PepperMediaStreamTrackHostBase::OnHostMsgEnqueueBuffer(context,
                                                                   index);
   } else {
@@ skipping 44 matching lines @@
                                   kDefaultOutputFrameRate,
                                   ToPixelFormat(plugin_frame_format_)));
   }
 
   // Makes the frame available again for plugin.
   SendEnqueueBufferMessageToPlugin(index);
   return PP_OK;
 }
 
 void PepperMediaStreamVideoTrackHost::OnVideoFrame(
-    const scoped_refptr<VideoFrame>& frame) {
+    const scoped_refptr<VideoFrame>& frame,
+    const media::VideoCaptureFormat& format) {
   DCHECK(frame);
   // TODO(penghuang): Check |frame->end_of_stream()| and close the track.
   PP_VideoFrame_Format ppformat = ToPpapiFormat(frame->format());
   if (ppformat == PP_VIDEOFRAME_FORMAT_UNKNOWN)
     return;
 
   if (source_frame_size_.IsEmpty()) {
     source_frame_size_ = frame->coded_size();
     source_frame_format_ = ppformat;
     InitBuffers();
   }
 
   int32_t index = buffer_manager()->DequeueBuffer();
   // Drop frames if the underlying buffer is full.
   if (index < 0) {
     DVLOG(1) << "A frame is dropped.";
     return;
   }
 
   CHECK(frame->coded_size() == source_frame_size_) << "Frame size is changed";
   CHECK_EQ(ppformat, source_frame_format_) << "Frame format is changed.";
 
   gfx::Size size = GetTargetSize(source_frame_size_, plugin_frame_size_);
-  PP_VideoFrame_Format format =
+  ppformat =
       GetTargetFormat(source_frame_format_, plugin_frame_format_);
   ppapi::MediaStreamBuffer::Video* buffer =
       &(buffer_manager()->GetBufferPointer(index)->video);
   buffer->header.size = buffer_manager()->buffer_size();
   buffer->header.type = ppapi::MediaStreamBuffer::TYPE_VIDEO;
   buffer->timestamp = frame->timestamp().InSecondsF();
-  buffer->format = format;
+  buffer->format = ppformat;
   buffer->size.width = size.width();
   buffer->size.height = size.height();
   buffer->data_size = frame_data_size_;
-  ConvertFromMediaVideoFrame(frame, format, size, buffer->data);
+  ConvertFromMediaVideoFrame(frame, ppformat, size, buffer->data);
 
   SendEnqueueBufferMessageToPlugin(index);
 }
 
 void PepperMediaStreamVideoTrackHost::GetCurrentSupportedFormats(
     int max_requested_width, int max_requested_height,
     const VideoCaptureDeviceFormatsCB& callback) {
   if (type_ != kWrite) {
     DVLOG(1) << "GetCurrentSupportedFormats is only supported in output mode.";
     callback.Run(media::VideoCaptureFormats());
@@ skipping 15 matching lines @@
   frame_deliverer_ = new FrameDeliverer(io_message_loop(), frame_callback);
 }
 
 void PepperMediaStreamVideoTrackHost::StopSourceImpl() {
   output_started_ = false;
   frame_deliverer_ = NULL;
 }
 
 void PepperMediaStreamVideoTrackHost::DidConnectPendingHostToResource() {
   if (!connected_) {
-    MediaStreamVideoSink::AddToVideoTrack(this, track_);
+    MediaStreamVideoSink::AddToVideoTrack(
+        this,
+        media::BindToCurrentLoop(
+            base::Bind(
+                &PepperMediaStreamVideoTrackHost::OnVideoFrame,
+                weak_factory_.GetWeakPtr())),
+        track_);
     connected_ = true;
   }
 }
 
 int32_t PepperMediaStreamVideoTrackHost::OnResourceMessageReceived(
     const IPC::Message& msg,
     HostMessageContext* context) {
   IPC_BEGIN_MESSAGE_MAP(PepperMediaStreamVideoTrackHost, msg)
   PPAPI_DISPATCH_HOST_RESOURCE_CALL(
       PpapiHostMsg_MediaStreamVideoTrack_Configure, OnHostMsgConfigure)
@@ skipping 61 matching lines @@
            base::Unretained(this)),
        enabled);
 }
 
 void PepperMediaStreamVideoTrackHost::OnTrackStarted(
     MediaStreamSource* source, bool success) {
   DVLOG(3) << "OnTrackStarted result: " << success;
 }
 
 }  // namespace content