Cast: deliver video frames on the IO thread

content/renderer/media/video_source_handler.cc

 // Copyright (c) 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/video_source_handler.h"
 
 #include <string>
 
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/synchronization/lock.h"
 #include "content/public/renderer/media_stream_video_sink.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_registry_interface.h"
+#include "media/base/bind_to_current_loop.h"
+#include "media/video/capture/video_capture_types.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
 #include "url/gurl.h"
 
 namespace content {
 
 // PpFrameReceiver implements MediaStreamVideoSink so that it can be attached
 // to video track to receive the captured frame.
 // It can be attached to a FrameReaderInterface to output the received frame.
 class PpFrameReceiver : public MediaStreamVideoSink {
  public:
-  PpFrameReceiver() : reader_(NULL) {}
+  PpFrameReceiver(blink::WebMediaStreamTrack track)
+    : track_(track),
+      reader_(NULL),
+      weak_factory_(this) {
+  }
+
   virtual ~PpFrameReceiver() {}
 
-  // Implements MediaStreamVideoSink.
-  virtual void OnVideoFrame(
-      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE {
-    base::AutoLock auto_lock(lock_);
+  void SetReader(FrameReaderInterface* reader) {
+    if (reader) {
+      DCHECK(!reader_);
+      MediaStreamVideoSink::AddToVideoTrack(
+          this,
+          media::BindToCurrentLoop(
+              base::Bind(
+                  &PpFrameReceiver::OnVideoFrame,
+                  weak_factory_.GetWeakPtr())),
+          track_);
+    } else {
+      DCHECK(reader_);
+      MediaStreamVideoSink::RemoveFromVideoTrack(this, track_);
+      weak_factory_.InvalidateWeakPtrs();
+    }
+    reader_ = reader;
+  }
+
+  void OnVideoFrame(
+      const scoped_refptr<media::VideoFrame>& frame,
+      const media::VideoCaptureFormat& format) {
     if (reader_) {

[Ronghua Wu (Left Chromium), 2014/05/08 21:32:14]

OnVideoFrame is called from the io thread, and SetReader will be called on
render thread. How do you protect |reader_| from data racing?

[Alpha Left Google, 2014/05/08 21:48:41]

OnVideoFrame is *NOT* called on the IO thread because of the use of
BindToCurrentLoop. It will be called on the render thread.

[Ronghua Wu (Left Chromium), 2014/05/08 22:00:04]

ic

       reader_->GotFrame(frame);
     }
   }
 
-  void SetReader(FrameReaderInterface* reader) {
-    base::AutoLock auto_lock(lock_);
-    reader_ = reader;
-  }
-
  private:
+  blink::WebMediaStreamTrack track_;
   FrameReaderInterface* reader_;
-  base::Lock lock_;
+  base::WeakPtrFactory<PpFrameReceiver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PpFrameReceiver);
 };
 
 VideoSourceHandler::VideoSourceHandler(
     MediaStreamRegistryInterface* registry)
     : registry_(registry) {
 }
 
 VideoSourceHandler::~VideoSourceHandler() {
@@ skipping 46 matching lines @@
   stream.videoTracks(video_tracks);
   if (video_tracks.isEmpty()) {
     LOG(ERROR) << "GetFirstVideoSource - non video tracks available."
                << " url: " << url;
     return blink::WebMediaStreamTrack();
   }
 
   return video_tracks[0];
 }
 
-MediaStreamVideoSink* VideoSourceHandler::GetReceiver(
-    FrameReaderInterface* reader) {
+void VideoSourceHandler::DeliverFrameForTesting(
+    FrameReaderInterface* reader,
+    const scoped_refptr<media::VideoFrame>& frame) {
   SourceInfoMap::iterator it = reader_to_receiver_.find(reader);
   if (it == reader_to_receiver_.end()) {
-    return NULL;
+    return;
   }
-  return it->second->receiver_.get();
+  PpFrameReceiver* receiver = it->second->receiver_.get();
+  receiver->OnVideoFrame(frame, media::VideoCaptureFormat());
 }
 
 VideoSourceHandler::SourceInfo::SourceInfo(
     const blink::WebMediaStreamTrack& blink_track,
     FrameReaderInterface* reader)
-    : receiver_(new PpFrameReceiver()),
-      track_(blink_track) {
-  MediaStreamVideoSink::AddToVideoTrack(receiver_.get(), track_);
+    : receiver_(new PpFrameReceiver(blink_track)) {
   receiver_->SetReader(reader);
 }
 
 VideoSourceHandler::SourceInfo::~SourceInfo() {
-  MediaStreamVideoSink::RemoveFromVideoTrack(receiver_.get(), track_);
   receiver_->SetReader(NULL);
 }
 
 }  // namespace content
-