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

content/renderer/media/webrtc/video_destination_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/webrtc/video_destination_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 
 namespace content {
 
 class PpFrameWriter::FrameWriterDelegate
     : public base::RefCountedThreadSafe<FrameWriterDelegate> {
  public:
   FrameWriterDelegate(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
       const VideoCaptureDeliverFrameCB& new_frame_callback);
 
-  void DeliverFrame(const scoped_refptr<media::VideoFrame>& frame,
-                    const media::VideoCaptureFormat& format);
+  void DeliverFrame(const scoped_refptr<media::VideoFrame>& frame);
  private:
   friend class base::RefCountedThreadSafe<FrameWriterDelegate>;
   virtual ~FrameWriterDelegate();
 
-  void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame,
-                        const media::VideoCaptureFormat& format);
+  void DeliverFrameOnIO(const scoped_refptr<media::VideoFrame>& frame);
 
   scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   VideoCaptureDeliverFrameCB new_frame_callback_;
 };
 
 PpFrameWriter::FrameWriterDelegate::FrameWriterDelegate(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy,
     const VideoCaptureDeliverFrameCB& new_frame_callback)
     : io_message_loop_(io_message_loop_proxy),
       new_frame_callback_(new_frame_callback) {
 }
 
 PpFrameWriter::FrameWriterDelegate::~FrameWriterDelegate() {
 }
 
 void PpFrameWriter::FrameWriterDelegate::DeliverFrame(
-    const scoped_refptr<media::VideoFrame>& frame,
-    const media::VideoCaptureFormat& format) {
+    const scoped_refptr<media::VideoFrame>& frame) {
   io_message_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&FrameWriterDelegate::DeliverFrameOnIO,
-                 this, frame, format));
+      base::Bind(&FrameWriterDelegate::DeliverFrameOnIO, this, frame));
 }
 
 void PpFrameWriter::FrameWriterDelegate::DeliverFrameOnIO(
-     const scoped_refptr<media::VideoFrame>& frame,
-     const media::VideoCaptureFormat& format) {
+     const scoped_refptr<media::VideoFrame>& frame) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   // The local time when this frame is generated is unknown so give a null
   // value to |estimated_capture_time|.
-  new_frame_callback_.Run(frame, format, base::TimeTicks());
+  new_frame_callback_.Run(frame, base::TimeTicks());
 }
 
 PpFrameWriter::PpFrameWriter() {
   DVLOG(3) << "PpFrameWriter ctor";
 }
 
 PpFrameWriter::~PpFrameWriter() {
   DVLOG(3) << "PpFrameWriter dtor";
 }
 
@@ skipping 61 matching lines @@
 
   if (state() != MediaStreamVideoSource::STARTED)
     return;
 
   const base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
       time_stamp_ns / base::Time::kNanosecondsPerMicrosecond);
 
   scoped_refptr<media::VideoFrame> new_frame =
       frame_pool_.CreateFrame(media::VideoFrame::YV12, frame_size,
                               gfx::Rect(frame_size), frame_size, timestamp);
-  media::VideoCaptureFormat format(
-      frame_size,
-      MediaStreamVideoSource::kUnknownFrameRate,
-      media::PIXEL_FORMAT_YV12);
 
   // TODO(magjed): Chrome OS is not ready for switching from BGRA to ARGB.
   // Remove this once http://crbug/434007 is fixed. We have a corresponding
   // problem when we send frames to the effects plugin in PepperVideoSourceHost.
 #if defined(OS_CHROMEOS)
   auto libyuv_xxxx_to_i420 = &libyuv::BGRAToI420;
 #else
   auto libyuv_xxxx_to_i420 = &libyuv::ARGBToI420;
 #endif
   libyuv_xxxx_to_i420(src_data,
                       src_stride,
                       new_frame->data(media::VideoFrame::kYPlane),
                       new_frame->stride(media::VideoFrame::kYPlane),
                       new_frame->data(media::VideoFrame::kUPlane),
                       new_frame->stride(media::VideoFrame::kUPlane),
                       new_frame->data(media::VideoFrame::kVPlane),
                       new_frame->stride(media::VideoFrame::kVPlane),
                       width,
                       height);
 
-  delegate_->DeliverFrame(new_frame, format);
+  delegate_->DeliverFrame(new_frame);
 }
 
 // PpFrameWriterProxy is a helper class to make sure the user won't use
 // PpFrameWriter after it is released (IOW its owner - WebMediaStreamSource -
 // is released).
 class PpFrameWriterProxy : public FrameWriterInterface {
  public:
   explicit PpFrameWriterProxy(const base::WeakPtr<PpFrameWriter>& writer)
       : writer_(writer) {
     DCHECK(writer_ != NULL);
@@ skipping 54 matching lines @@
 
   stream.addTrack(MediaStreamVideoTrack::CreateVideoTrack(
       writer, constraints, MediaStreamVideoSource::ConstraintsCallback(),
       track_enabled));
 
   *frame_writer = new PpFrameWriterProxy(writer->AsWeakPtr());
   return true;
 }
 
 }  // namespace content