MediaStreamVideo*/VideoTrackAdapter and RTCVideoRenderer (small) cleanup

content/renderer/media/media_stream_video_track.cc

Index: content/renderer/media/media_stream_video_track.cc
diff --git a/content/renderer/media/media_stream_video_track.cc b/content/renderer/media/media_stream_video_track.cc
index 8a049a6db17d5e5fd93f762ee8f0d51b3949c4bb..07cc2afedcc3073bc644ae056a9130fb0fcc8af5 100644
--- a/content/renderer/media/media_stream_video_track.cc
+++ b/content/renderer/media/media_stream_video_track.cc
@@ -26,6 +26,8 @@ void ResetCallback(scoped_ptr<VideoCaptureDeliverFrameCB> callback) {
 class MediaStreamVideoTrack::FrameDeliverer
     : public base::RefCountedThreadSafe<FrameDeliverer> {
  public:
+  typedef void* VideoSinkId;

[wolenetz, 2015/03/11 23:37:37]

aside: is void* truly necessary, or can we have some more specific type?!

[mcasas, 2015/03/13 01:09:33]

Good suggestion, it can be MediaStreamVideoSink*
so I adjusted the typedef - I think is still good
to have an alias so it's clear that is a pointer
used as an id.

+
   FrameDeliverer(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
       bool enabled);
@@ -34,13 +36,13 @@ class MediaStreamVideoTrack::FrameDeliverer
 
   // Add |callback| to receive video frames on the IO-thread.
   // Must be called on the main render thread.
-  void AddCallback(void* id, const VideoCaptureDeliverFrameCB& callback);
+  void AddCallback(VideoSinkId id, const VideoCaptureDeliverFrameCB& callback);
 
   // Removes |callback| associated with |id| from receiving video frames if |id|
   // has been added. It is ok to call RemoveCallback even if the |id| has not
   // been added. Note that the added callback will be reset on the main thread.
   // Must be called on the main render thread.
-  void RemoveCallback(void* id);
+  void RemoveCallback(VideoSinkId id);
 
   // Triggers all registered callbacks with |frame|, |format| and
   // |estimated_capture_time| as parameters. Must be called on the IO-thread.
@@ -50,9 +52,11 @@ class MediaStreamVideoTrack::FrameDeliverer
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
-  void AddCallbackOnIO(void* id, const VideoCaptureDeliverFrameCB& callback);
+  void AddCallbackOnIO(VideoSinkId id,
+                       const VideoCaptureDeliverFrameCB& callback);
   void RemoveCallbackOnIO(
-      void* id, const scoped_refptr<base::MessageLoopProxy>& message_loop);
+      VideoSinkId id,
+      const scoped_refptr<base::MessageLoopProxy>& message_loop);
 
   void SetEnabledOnIO(bool enabled);
   // Returns |black_frame_| where the size and time stamp is set to the same as
@@ -61,14 +65,15 @@ class MediaStreamVideoTrack::FrameDeliverer
       const scoped_refptr<media::VideoFrame>& reference_frame);
 
   // Used to DCHECK that AddCallback and RemoveCallback are called on the main
-  // render thread.
-  base::ThreadChecker thread_checker_;
-  scoped_refptr<base::MessageLoopProxy> io_message_loop_;
+  // Render Thread.
+  base::ThreadChecker render_thread_checker_;
+  const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
 
   bool enabled_;
   scoped_refptr<media::VideoFrame> black_frame_;
 
-  typedef std::pair<void*, VideoCaptureDeliverFrameCB> VideoIdCallbackPair;
+  typedef std::pair<VideoSinkId, VideoCaptureDeliverFrameCB>
+      VideoIdCallbackPair;
   std::vector<VideoIdCallbackPair> callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameDeliverer);
@@ -86,9 +91,9 @@ MediaStreamVideoTrack::FrameDeliverer::~FrameDeliverer() {
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::AddCallback(
-    void* id,
+    VideoSinkId id,
     const VideoCaptureDeliverFrameCB& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FrameDeliverer::AddCallbackOnIO,
@@ -96,14 +101,14 @@ void MediaStreamVideoTrack::FrameDeliverer::AddCallback(
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::AddCallbackOnIO(
-    void* id,
+    VideoSinkId id,
     const VideoCaptureDeliverFrameCB& callback) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   callbacks_.push_back(std::make_pair(id, callback));
 }
 
-void MediaStreamVideoTrack::FrameDeliverer::RemoveCallback(void* id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+void MediaStreamVideoTrack::FrameDeliverer::RemoveCallback(VideoSinkId id) {
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FrameDeliverer::RemoveCallbackOnIO,
@@ -111,7 +116,8 @@ void MediaStreamVideoTrack::FrameDeliverer::RemoveCallback(void* id) {
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::RemoveCallbackOnIO(
-    void* id, const scoped_refptr<base::MessageLoopProxy>& message_loop) {
+    VideoSinkId id,
+    const scoped_refptr<base::MessageLoopProxy>& message_loop) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   std::vector<VideoIdCallbackPair>::iterator it = callbacks_.begin();
   for (; it != callbacks_.end(); ++it) {
@@ -128,7 +134,7 @@ void MediaStreamVideoTrack::FrameDeliverer::RemoveCallbackOnIO(
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabled(bool enabled) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   io_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FrameDeliverer::SetEnabledOnIO,
@@ -206,7 +212,7 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
 }
 
 MediaStreamVideoTrack::~MediaStreamVideoTrack() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   DCHECK(sinks_.empty());
   Stop();
   DVLOG(3) << "~MediaStreamVideoTrack()";
@@ -214,14 +220,14 @@ MediaStreamVideoTrack::~MediaStreamVideoTrack() {
 
 void MediaStreamVideoTrack::AddSink(
     MediaStreamVideoSink* sink, const VideoCaptureDeliverFrameCB& callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   DCHECK(std::find(sinks_.begin(), sinks_.end(), sink) == sinks_.end());
   sinks_.push_back(sink);
   frame_deliverer_->AddCallback(sink, callback);
 }
 
 void MediaStreamVideoTrack::RemoveSink(MediaStreamVideoSink* sink) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   std::vector<MediaStreamVideoSink*>::iterator it =
       std::find(sinks_.begin(), sinks_.end(), sink);
   DCHECK(it != sinks_.end());
@@ -230,16 +236,14 @@ void MediaStreamVideoTrack::RemoveSink(MediaStreamVideoSink* sink) {
 }
 
 void MediaStreamVideoTrack::SetEnabled(bool enabled) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   frame_deliverer_->SetEnabled(enabled);
-  for (std::vector<MediaStreamVideoSink*>::const_iterator it = sinks_.begin();
-       it != sinks_.end(); ++it) {
-    (*it)->OnEnabledChanged(enabled);
-  }
+  for (auto* sink : sinks_)
+    sink->OnEnabledChanged(enabled);
 }
 
 void MediaStreamVideoTrack::Stop() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(render_thread_checker_.CalledOnValidThread());
   if (source_) {
     source_->RemoveTrack(this);
     source_ = NULL;
@@ -249,11 +253,9 @@ void MediaStreamVideoTrack::Stop() {
 
 void MediaStreamVideoTrack::OnReadyStateChanged(
     blink::WebMediaStreamSource::ReadyState state) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  for (std::vector<MediaStreamVideoSink*>::const_iterator it = sinks_.begin();
-       it != sinks_.end(); ++it) {
-    (*it)->OnReadyStateChanged(state);
-  }
+  DCHECK(render_thread_checker_.CalledOnValidThread());
+  for (auto* sink : sinks_)
+    sink->OnReadyStateChanged(state);
 }
 
 }  // namespace content