Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

content/renderer/media/media_stream_video_track.cc

 // Copyright 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/media_stream_video_track.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
@@ skipping 27 matching lines @@
 
   // 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);
 
   // Triggers all registered callbacks with |frame|, |format| and
   // |estimated_capture_time| as parameters. Must be called on the IO-thread.
   void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame,
-                        const media::VideoCaptureFormat& format,
                         const base::TimeTicks& estimated_capture_time);
 
  private:
   friend class base::RefCountedThreadSafe<FrameDeliverer>;
   virtual ~FrameDeliverer();
   void AddCallbackOnIO(void* id, const VideoCaptureDeliverFrameCB& callback);
   void RemoveCallbackOnIO(
       void* id, const scoped_refptr<base::MessageLoopProxy>& message_loop);
 
   void SetEnabledOnIO(bool enabled);
@@ skipping 79 matching lines @@
 
 void MediaStreamVideoTrack::FrameDeliverer::SetEnabledOnIO(bool enabled) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   enabled_ = enabled;
   if (enabled_)
     black_frame_ = NULL;
 }
 
 void MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO(
     const scoped_refptr<media::VideoFrame>& frame,
-    const media::VideoCaptureFormat& format,
     const base::TimeTicks& estimated_capture_time) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   const scoped_refptr<media::VideoFrame>& video_frame =
       enabled_ ? frame : GetBlackFrame(frame);
-
-  for (std::vector<VideoIdCallbackPair>::iterator it = callbacks_.begin();
-       it != callbacks_.end(); ++it) {
-    it->second.Run(video_frame, format, estimated_capture_time);
-  }
+  for (const auto& entry : callbacks_)
+    entry.second.Run(video_frame, estimated_capture_time);
 }
 
 const scoped_refptr<media::VideoFrame>&
 MediaStreamVideoTrack::FrameDeliverer::GetBlackFrame(
     const scoped_refptr<media::VideoFrame>& reference_frame) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   if (!black_frame_.get() ||
       black_frame_->natural_size() != reference_frame->natural_size())
     black_frame_ =
         media::VideoFrame::CreateBlackFrame(reference_frame->natural_size());
@@ skipping 87 matching lines @@
 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);
   }
 }
 
 }  // namespace content