Replace media::VideoCapture::VideoFrameBuffer with media::VideoFrame.

This CL removes a redundant class in the form of
media::VideoCapture::VideoFrameBuffer, and replaces it with
media::VideoFrame.  Also: as media::VideoFrame has an embedded
destruction callback, use this to handle buffer returns on
the video capture stack, and remove the explicit
VideoCapture::FeedBuffer entry point.

BUG=None
TEST=local build, content_unittests, run on desktop Linux with
     screen capture and webcam

Review URL: https://chromiumcodereview.appspot.com/23587018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@223434 0039d316-1c4b-4281-b951-d872f2087c98

content/renderer/media/rtc_video_capture_delegate.cc

@@ -81,13 +81,15 @@ void RtcVideoCaptureDelegate::OnRemoved(media::VideoCapture* capture) {
   Release();
 }
 
-void RtcVideoCaptureDelegate::OnBufferReady(
+void RtcVideoCaptureDelegate::OnFrameReady(
     media::VideoCapture* capture,
-    scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
+    const scoped_refptr<media::VideoFrame>& frame) {
   message_loop_proxy_->PostTask(
       FROM_HERE,
-      base::Bind(&RtcVideoCaptureDelegate::OnBufferReadyOnCaptureThread,
-                 this, capture, buf));
+      base::Bind(&RtcVideoCaptureDelegate::OnFrameReadyOnCaptureThread,
+                 this,
+                 capture,
+                 frame));
 }
 
 void RtcVideoCaptureDelegate::OnDeviceInfoReceived(
@@ -100,9 +102,9 @@ void RtcVideoCaptureDelegate::OnDeviceInfoChanged(
     const media::VideoCaptureParams& device_info) {
 }
 
-void RtcVideoCaptureDelegate::OnBufferReadyOnCaptureThread(
+void RtcVideoCaptureDelegate::OnFrameReadyOnCaptureThread(
     media::VideoCapture* capture,
-    scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) {
+    const scoped_refptr<media::VideoFrame>& frame) {
   if (!captured_callback_.is_null()) {
     if (!got_first_frame_) {
       got_first_frame_ = true;
@@ -110,9 +112,8 @@ void RtcVideoCaptureDelegate::OnBufferReadyOnCaptureThread(
         state_callback_.Run(CAPTURE_RUNNING);
     }
 
-    captured_callback_.Run(*buf.get());
+    captured_callback_.Run(frame);
   }
-  capture->FeedBuffer(buf);
 }
 
 void RtcVideoCaptureDelegate::OnErrorOnCaptureThread(

content/renderer/media/rtc_video_capture_delegate.h

@@ -29,9 +29,9 @@ class RtcVideoCaptureDelegate
     CAPTURE_FAILED,  // The capturer failed to start.
   };
 
-  typedef base::Callback<void(const media::VideoCapture::VideoFrameBuffer& buf)>
+  typedef base::Callback<void(const scoped_refptr<media::VideoFrame>&)>
       FrameCapturedCallback;
-  typedef base::Callback<void(CaptureState state)> StateChangeCallback;
+  typedef base::Callback<void(CaptureState)> StateChangeCallback;
 
   RtcVideoCaptureDelegate(const media::VideoCaptureSessionId id,
                           VideoCaptureImplManager* vc_manager);
@@ -48,9 +48,9 @@ class RtcVideoCaptureDelegate
   virtual void OnPaused(media::VideoCapture* capture) OVERRIDE;
   virtual void OnError(media::VideoCapture* capture, int error_code) OVERRIDE;
   virtual void OnRemoved(media::VideoCapture* capture) OVERRIDE;
-  virtual void OnBufferReady(
+  virtual void OnFrameReady(
       media::VideoCapture* capture,
-      scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf) OVERRIDE;
+      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE;
   virtual void OnDeviceInfoReceived(
       media::VideoCapture* capture,
       const media::VideoCaptureParams& device_info) OVERRIDE;
@@ -63,9 +63,9 @@ class RtcVideoCaptureDelegate
 
   virtual ~RtcVideoCaptureDelegate();
 
-  void OnBufferReadyOnCaptureThread(
+  void OnFrameReadyOnCaptureThread(
       media::VideoCapture* capture,
-      scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf);
+      const scoped_refptr<media::VideoFrame>& frame);
   void OnErrorOnCaptureThread(media::VideoCapture* capture);
   void OnRemovedOnCaptureThread(media::VideoCapture* capture);
 

content/renderer/media/rtc_video_capturer.cc

@@ -9,14 +9,12 @@
 
 namespace content {
 
-RtcVideoCapturer::RtcVideoCapturer(
-    const media::VideoCaptureSessionId id,
-    VideoCaptureImplManager* vc_manager,
-    bool is_screencast)
+RtcVideoCapturer::RtcVideoCapturer(const media::VideoCaptureSessionId id,
+                                   VideoCaptureImplManager* vc_manager,
+                                   bool is_screencast)
     : is_screencast_(is_screencast),
       delegate_(new RtcVideoCaptureDelegate(id, vc_manager)),
-      state_(VIDEO_CAPTURE_STATE_STOPPED) {
-}
+      state_(VIDEO_CAPTURE_STATE_STOPPED) {}
 
 RtcVideoCapturer::~RtcVideoCapturer() {
   DCHECK(VIDEO_CAPTURE_STATE_STOPPED);
@@ -40,8 +38,9 @@ cricket::CaptureState RtcVideoCapturer::Start(
   SetCaptureFormat(&capture_format);
 
   state_ = VIDEO_CAPTURE_STATE_STARTED;
-  start_time_ = base::Time::Now();
-  delegate_->StartCapture(cap,
+  first_frame_timestamp_ = media::kNoTimestamp();
+  delegate_->StartCapture(
+      cap,
       base::Bind(&RtcVideoCapturer::OnFrameCaptured, base::Unretained(this)),
       base::Bind(&RtcVideoCapturer::OnStateChange, base::Unretained(this)));
   // Update the desired aspect ratio so that later the video frame can be
@@ -95,34 +94,40 @@ bool RtcVideoCapturer::GetBestCaptureFormat(const cricket::VideoFormat& desired,
 }
 
 void RtcVideoCapturer::OnFrameCaptured(
-    const media::VideoCapture::VideoFrameBuffer& buf) {
+    const scoped_refptr<media::VideoFrame>& frame) {
+  if (first_frame_timestamp_ == media::kNoTimestamp())
+    first_frame_timestamp_ = frame->GetTimestamp();
+
   // Currently, |fourcc| is always I420.
-  cricket::CapturedFrame frame;
-  frame.width = buf.width;
-  frame.height = buf.height;
-  frame.fourcc = cricket::FOURCC_I420;
-  frame.data_size = buf.buffer_size;
+  cricket::CapturedFrame captured_frame;
+  captured_frame.width = frame->coded_size().width();
+  captured_frame.height = frame->coded_size().height();
+  captured_frame.fourcc = cricket::FOURCC_I420;
   // cricket::CapturedFrame time is in nanoseconds.
-  frame.elapsed_time = (buf.timestamp - start_time_).InMicroseconds() *
-      base::Time::kNanosecondsPerMicrosecond;
-  frame.time_stamp =
-      (buf.timestamp - base::Time::UnixEpoch()).InMicroseconds() *
+  captured_frame.elapsed_time =
+      (frame->GetTimestamp() - first_frame_timestamp_).InMicroseconds() *
       base::Time::kNanosecondsPerMicrosecond;
-  frame.data = buf.memory_pointer;
-  frame.pixel_height = 1;
-  frame.pixel_width = 1;
-
-  TRACE_EVENT_INSTANT2("rtc_video_capturer",
-                       "OnFrameCaptured",
-                       TRACE_EVENT_SCOPE_THREAD,
-                       "elapsed time",
-                       frame.elapsed_time,
-                       "timestamp_ms",
-                       frame.time_stamp / talk_base::kNumNanosecsPerMillisec);
+  captured_frame.time_stamp = frame->GetTimestamp().InMicroseconds() *
+                              base::Time::kNanosecondsPerMicrosecond;
+  // TODO(sheu): we assume contiguous layout of image planes.
+  captured_frame.data = frame->data(0);
+  captured_frame.data_size =
+      media::VideoFrame::AllocationSize(frame->format(), frame->coded_size());
+  captured_frame.pixel_height = 1;
+  captured_frame.pixel_width = 1;
+
+  TRACE_EVENT_INSTANT2(
+      "rtc_video_capturer",
+      "OnFrameCaptured",
+      TRACE_EVENT_SCOPE_THREAD,
+      "elapsed time",
+      captured_frame.elapsed_time,
+      "timestamp_ms",
+      captured_frame.time_stamp / talk_base::kNumNanosecsPerMillisec);
 
   // This signals to libJingle that a new VideoFrame is available.
   // libJingle have no assumptions on what thread this signal come from.
-  SignalFrameCaptured(this, &frame);
+  SignalFrameCaptured(this, &captured_frame);
 }
 
 void RtcVideoCapturer::OnStateChange(

content/renderer/media/rtc_video_capturer.h

@@ -41,8 +41,7 @@ class RtcVideoCapturer
 
  private:
   // Frame captured callback method.
-  virtual void OnFrameCaptured(
-      const media::VideoCapture::VideoFrameBuffer& frame);
+  virtual void OnFrameCaptured(const scoped_refptr<media::VideoFrame>& frame);
 
   // State change callback, must be called on same thread as Start is called.
   void OnStateChange(RtcVideoCaptureDelegate::CaptureState state);
@@ -50,7 +49,7 @@ class RtcVideoCapturer
   const bool is_screencast_;
   scoped_refptr<RtcVideoCaptureDelegate> delegate_;
   VideoCaptureState state_;
-  base::Time start_time_;
+  base::TimeDelta first_frame_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcVideoCapturer);
 };

content/renderer/media/video_capture_impl.cc

@@ -8,26 +8,35 @@
 #include "base/stl_util.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
+#include "media/base/bind_to_loop.h"
 #include "media/base/limits.h"
 
 namespace content {
 
-struct VideoCaptureImpl::DIBBuffer {
+class VideoCaptureImpl::ClientBuffer : public base::RefCounted<ClientBuffer> {
  public:
-  DIBBuffer(
-      base::SharedMemory* d,
-      media::VideoCapture::VideoFrameBuffer* ptr)
-      : dib(d),
-        mapped_memory(ptr),
-        references(0) {
-  }
-  ~DIBBuffer() {}
-
-  scoped_ptr<base::SharedMemory> dib;
-  scoped_refptr<media::VideoCapture::VideoFrameBuffer> mapped_memory;
-
-  // Number of clients which hold this DIB.
-  int references;
+  ClientBuffer(scoped_ptr<base::SharedMemory> buffer,
+               size_t buffer_size,
+               int frame_width,
+               int frame_height,
+               int frame_stride)
+      : buffer(buffer.Pass()),
+        buffer_size(buffer_size),
+        frame_width(frame_width),
+        frame_height(frame_height),
+        frame_stride(frame_stride) {}
+  const scoped_ptr<base::SharedMemory> buffer;
+  const size_t buffer_size;
+  const int frame_width;   // In pixels.
+  const int frame_height;  // In pixels.
+  const int frame_stride;  // In pixels.
+
+ private:
+  friend class base::RefCounted<ClientBuffer>;
+
+  virtual ~ClientBuffer() {}
+
+  DISALLOW_COPY_AND_ASSIGN(ClientBuffer);
 };
 
 bool VideoCaptureImpl::CaptureStarted() {
@@ -55,6 +64,7 @@ VideoCaptureImpl::VideoCaptureImpl(
       capture_message_loop_proxy_(capture_message_loop_proxy),
       io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()),
       device_id_(0),
+      client_buffer_weak_this_factory_(this),
       video_type_(media::PIXEL_FORMAT_I420),
       device_info_available_(false),
       suspended_(false),
@@ -63,9 +73,7 @@ VideoCaptureImpl::VideoCaptureImpl(
   capture_format_.session_id = id;
 }
 
-VideoCaptureImpl::~VideoCaptureImpl() {
-  STLDeleteValues(&cached_dibs_);
-}
+VideoCaptureImpl::~VideoCaptureImpl() {}
 
 void VideoCaptureImpl::Init() {
   if (!io_message_loop_proxy_->BelongsToCurrentThread()) {
@@ -99,12 +107,6 @@ void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler) {
                  base::Unretained(this), handler));
 }
 
-void VideoCaptureImpl::FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) {
-  capture_message_loop_proxy_->PostTask(FROM_HERE,
-      base::Bind(&VideoCaptureImpl::DoFeedBufferOnCaptureThread,
-                 base::Unretained(this), buffer));
-}
-
 void VideoCaptureImpl::OnBufferCreated(
     base::SharedMemoryHandle handle,
     int length, int buffer_id) {
@@ -235,25 +237,8 @@ void VideoCaptureImpl::DoStopCaptureOnCaptureThread(
   if (clients_.empty()) {
     DVLOG(1) << "StopCapture: No more client, stopping ...";
     StopDevice();
-  }
-}
-
-void VideoCaptureImpl::DoFeedBufferOnCaptureThread(
-    scoped_refptr<VideoFrameBuffer> buffer) {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-
-  CachedDIB::iterator it;
-  for (it = cached_dibs_.begin(); it != cached_dibs_.end(); ++it) {
-    if (buffer.get() == it->second->mapped_memory.get())
-      break;
-  }
-
-  if (it != cached_dibs_.end() && it->second) {
-    DCHECK_GT(it->second->references, 0);
-    --it->second->references;
-    if (it->second->references == 0) {
-      Send(new VideoCaptureHostMsg_BufferReady(device_id_, it->first));
-    }
+    client_buffers_.clear();
+    client_buffer_weak_this_factory_.InvalidateWeakPtrs();
   }
 }
 
@@ -271,20 +256,21 @@ void VideoCaptureImpl::DoBufferCreatedOnCaptureThread(
 
   DCHECK(device_info_available_);
 
-  media::VideoCapture::VideoFrameBuffer* buffer;
-  DCHECK(cached_dibs_.find(buffer_id) == cached_dibs_.end());
-
-  base::SharedMemory* dib = new base::SharedMemory(handle, false);
-  dib->Map(length);
-  buffer = new VideoFrameBuffer();
-  buffer->memory_pointer = static_cast<uint8*>(dib->memory());
-  buffer->buffer_size = length;
-  buffer->width = device_info_.width;
-  buffer->height = device_info_.height;
-  buffer->stride = device_info_.width;
+  scoped_ptr<base::SharedMemory> shm(new base::SharedMemory(handle, false));
+  if (!shm->Map(length)) {
+    DLOG(ERROR) << "DoBufferCreatedOnCaptureThread: Map() failed.";
+    return;
+  }
 
-  DIBBuffer* dib_buffer = new DIBBuffer(dib, buffer);
-  cached_dibs_[buffer_id] = dib_buffer;
+  bool inserted =
+      client_buffers_.insert(std::make_pair(
+                                 buffer_id,
+                                 new ClientBuffer(shm.Pass(),
+                                                  length,
+                                                  device_info_.width,
+                                                  device_info_.height,
+                                                  device_info_.width))).second;
+  DCHECK(inserted);
 }
 
 void VideoCaptureImpl::DoBufferReceivedOnCaptureThread(
@@ -296,15 +282,38 @@ void VideoCaptureImpl::DoBufferReceivedOnCaptureThread(
     return;
   }
 
-  media::VideoCapture::VideoFrameBuffer* buffer;
-  DCHECK(cached_dibs_.find(buffer_id) != cached_dibs_.end());
-  buffer = cached_dibs_[buffer_id]->mapped_memory.get();
-  buffer->timestamp = timestamp;
-
-  for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it) {
-    it->first->OnBufferReady(this, buffer);
-  }
-  cached_dibs_[buffer_id]->references = clients_.size();
+  ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
+  DCHECK(iter != client_buffers_.end());
+  scoped_refptr<ClientBuffer> buffer = iter->second;
+  scoped_refptr<media::VideoFrame> frame =
+      media::VideoFrame::WrapExternalSharedMemory(
+          media::VideoFrame::I420,
+          gfx::Size(buffer->frame_stride, buffer->frame_height),
+          gfx::Rect(0, 0, buffer->frame_width, buffer->frame_height),
+          gfx::Size(buffer->frame_width, buffer->frame_height),
+          reinterpret_cast<uint8*>(buffer->buffer->memory()),
+          buffer->buffer_size,
+          buffer->buffer->handle(),
+          // TODO(sheu): convert VideoCaptureMessageFilter::Delegate to use
+          // base::TimeTicks instead of base::Time.  http://crbug.com/249215
+          timestamp - base::Time::UnixEpoch(),
+          media::BindToLoop(
+              capture_message_loop_proxy_,
+              base::Bind(
+                  &VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread,
+                  client_buffer_weak_this_factory_.GetWeakPtr(),
+                  buffer_id,
+                  buffer)));
+
+  for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it)
+    it->first->OnFrameReady(this, frame);
+}
+
+void VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread(
+    int buffer_id,
+    const scoped_refptr<ClientBuffer>& buffer) {
+  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
+  Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id));
 }
 
 void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
@@ -316,7 +325,8 @@ void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
     case VIDEO_CAPTURE_STATE_STOPPED:
       state_ = VIDEO_CAPTURE_STATE_STOPPED;
       DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_;
-      STLDeleteValues(&cached_dibs_);
+      client_buffers_.clear();
+      client_buffer_weak_this_factory_.InvalidateWeakPtrs();
       if (!clients_.empty() || !clients_pending_on_restart_.empty())
         RestartCapture();
       break;
@@ -354,9 +364,7 @@ void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) {
 void VideoCaptureImpl::DoDeviceInfoReceivedOnCaptureThread(
     const media::VideoCaptureParams& device_info) {
   DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-  DCHECK(!ClientHasDIB());
-
-  STLDeleteValues(&cached_dibs_);
+  DCHECK(client_buffers_.empty());
 
   device_info_ = device_info;
   device_info_available_ = true;
@@ -462,16 +470,6 @@ void VideoCaptureImpl::Send(IPC::Message* message) {
                  message_filter_.get(), message));
 }
 
-bool VideoCaptureImpl::ClientHasDIB() const {
-  DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread());
-  for (CachedDIB::const_iterator it = cached_dibs_.begin();
-       it != cached_dibs_.end(); ++it) {
-    if (it->second->references > 0)
-      return true;
-  }
-  return false;
-}
-
 bool VideoCaptureImpl::RemoveClient(
     media::VideoCapture::EventHandler* handler,
     ClientInfo* clients) {

content/renderer/media/video_capture_impl.h

@@ -33,6 +33,7 @@
 #include <list>
 #include <map>
 
+#include "base/memory/weak_ptr.h"
 #include "content/common/content_export.h"
 #include "content/common/media/video_capture.h"
 #include "content/renderer/media/video_capture_message_filter.h"
@@ -53,7 +54,6 @@ class CONTENT_EXPORT VideoCaptureImpl
       media::VideoCapture::EventHandler* handler,
       const media::VideoCaptureCapability& capability) OVERRIDE;
   virtual void StopCapture(media::VideoCapture::EventHandler* handler) OVERRIDE;
-  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE;
   virtual bool CaptureStarted() OVERRIDE;
   virtual int CaptureWidth() OVERRIDE;
   virtual int CaptureHeight() OVERRIDE;
@@ -78,9 +78,9 @@ class CONTENT_EXPORT VideoCaptureImpl
   friend class VideoCaptureImplTest;
   friend class MockVideoCaptureImpl;
 
-  struct DIBBuffer;
+  class ClientBuffer;
   typedef std::map<media::VideoCapture::EventHandler*,
-      media::VideoCaptureCapability> ClientInfo;
+                   media::VideoCaptureCapability> ClientInfo;
 
   VideoCaptureImpl(media::VideoCaptureSessionId id,
                    base::MessageLoopProxy* capture_message_loop_proxy,
@@ -91,11 +91,12 @@ class CONTENT_EXPORT VideoCaptureImpl
       media::VideoCapture::EventHandler* handler,
       const media::VideoCaptureCapability& capability);
   void DoStopCaptureOnCaptureThread(media::VideoCapture::EventHandler* handler);
-  void DoFeedBufferOnCaptureThread(scoped_refptr<VideoFrameBuffer> buffer);
-
   void DoBufferCreatedOnCaptureThread(base::SharedMemoryHandle handle,
                                       int length, int buffer_id);
   void DoBufferReceivedOnCaptureThread(int buffer_id, base::Time timestamp);
+  void DoClientBufferFinishedOnCaptureThread(
+      int buffer_id,
+      const scoped_refptr<ClientBuffer>& buffer);
   void DoStateChangedOnCaptureThread(VideoCaptureState state);
   void DoDeviceInfoReceivedOnCaptureThread(
       const media::VideoCaptureParams& device_info);
@@ -116,7 +117,6 @@ class CONTENT_EXPORT VideoCaptureImpl
   virtual void Send(IPC::Message* message);
 
   // Helpers.
-  bool ClientHasDIB() const;
   bool RemoveClient(media::VideoCapture::EventHandler* handler,
                     ClientInfo* clients);
 
@@ -125,9 +125,13 @@ class CONTENT_EXPORT VideoCaptureImpl
   const scoped_refptr<base::MessageLoopProxy> io_message_loop_proxy_;
   int device_id_;
 
-  // Pool of DIBs. The key is buffer_id.
-  typedef std::map<int, DIBBuffer*> CachedDIB;
-  CachedDIB cached_dibs_;
+  // Buffers available for sending to the client.
+  typedef std::map<int32, scoped_refptr<ClientBuffer> > ClientBufferMap;
+  ClientBufferMap client_buffers_;
+  // WeakPtrFactory pointing back to |this| object, for use with
+  // media::VideoFrames constructed in OnBufferReceived() from buffers cached
+  // in |client_buffers_|.
+  base::WeakPtrFactory<VideoCaptureImpl> client_buffer_weak_this_factory_;
 
   ClientInfo clients_;
 

content/renderer/media/video_capture_impl_unittest.cc

@@ -40,9 +40,9 @@ class MockVideoCaptureClient : public media::VideoCapture::EventHandler {
   MOCK_METHOD1(OnPaused, void(media::VideoCapture* capture));
   MOCK_METHOD2(OnError, void(media::VideoCapture* capture, int error_code));
   MOCK_METHOD1(OnRemoved, void(media::VideoCapture* capture));
-  MOCK_METHOD2(OnBufferReady,
+  MOCK_METHOD2(OnFrameReady,
                void(media::VideoCapture* capture,
-                    scoped_refptr<media::VideoCapture::VideoFrameBuffer> buf));
+                    const scoped_refptr<media::VideoFrame>& frame));
   MOCK_METHOD2(OnDeviceInfoReceived,
                void(media::VideoCapture* capture,
                     const media::VideoCaptureParams& device_info));

content/renderer/media/video_capture_message_filter.h

@@ -87,8 +87,7 @@ class CONTENT_EXPORT VideoCaptureMessageFilter
                        int length, int buffer_id);
 
   // Receive a buffer from browser process.
-  void OnBufferReceived(int device_id,
-                        int buffer_id, base::Time timestamp);
+  void OnBufferReceived(int device_id, int buffer_id, base::Time timestamp);
 
   // State of browser process' video capture device has changed.
   void OnDeviceStateChanged(int device_id, VideoCaptureState state);

content/renderer/pepper/pepper_platform_video_capture.cc

@@ -71,12 +71,6 @@ void PepperPlatformVideoCapture::StopCapture(
   }
 }
 
-void PepperPlatformVideoCapture::FeedBuffer(
-    scoped_refptr<VideoFrameBuffer> buffer) {
-  if (video_capture_)
-    video_capture_->FeedBuffer(buffer);
-}
-
 bool PepperPlatformVideoCapture::CaptureStarted() {
   return handler_proxy_->state().started;
 }
@@ -145,16 +139,11 @@ void PepperPlatformVideoCapture::OnRemoved(VideoCapture* capture) {
   Release();  // Balance the AddRef() in StartCapture().
 }
 
-void PepperPlatformVideoCapture::OnBufferReady(
+void PepperPlatformVideoCapture::OnFrameReady(
     VideoCapture* capture,
-    scoped_refptr<VideoFrameBuffer> buffer) {
-  if (handler_) {
-    handler_->OnBufferReady(capture, buffer);
-  } else {
-    // Even after handler_ is detached, we have to return buffers that are in
-    // flight to us. Otherwise VideoCaptureController will not tear down.
-    FeedBuffer(buffer);
-  }
+    const scoped_refptr<media::VideoFrame>& frame) {
+  if (handler_)
+    handler_->OnFrameReady(capture, frame);
 }
 
 void PepperPlatformVideoCapture::OnDeviceInfoReceived(

content/renderer/pepper/pepper_platform_video_capture.h

@@ -44,7 +44,6 @@ class PepperPlatformVideoCapture
       media::VideoCapture::EventHandler* handler,
       const media::VideoCaptureCapability& capability) OVERRIDE;
   virtual void StopCapture(media::VideoCapture::EventHandler* handler) OVERRIDE;
-  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE;
   virtual bool CaptureStarted() OVERRIDE;
   virtual int CaptureWidth() OVERRIDE;
   virtual int CaptureHeight() OVERRIDE;
@@ -56,8 +55,9 @@ class PepperPlatformVideoCapture
   virtual void OnPaused(VideoCapture* capture) OVERRIDE;
   virtual void OnError(VideoCapture* capture, int error_code) OVERRIDE;
   virtual void OnRemoved(VideoCapture* capture) OVERRIDE;
-  virtual void OnBufferReady(VideoCapture* capture,
-                             scoped_refptr<VideoFrameBuffer> buffer) OVERRIDE;
+  virtual void OnFrameReady(
+      VideoCapture* capture,
+      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE;
   virtual void OnDeviceInfoReceived(
       VideoCapture* capture,
       const media::VideoCaptureParams& device_info) OVERRIDE;

content/renderer/pepper/pepper_video_capture_host.cc

@@ -129,29 +129,40 @@ void PepperVideoCaptureHost::OnError(media::VideoCapture* capture,
 void PepperVideoCaptureHost::OnRemoved(media::VideoCapture* capture) {
 }
 
-void PepperVideoCaptureHost::OnBufferReady(
+void PepperVideoCaptureHost::OnFrameReady(
     media::VideoCapture* capture,
-    scoped_refptr<media::VideoCapture::VideoFrameBuffer> buffer) {
-  DCHECK(buffer.get());
+    const scoped_refptr<media::VideoFrame>& frame) {
+  DCHECK(frame.get());
   for (uint32_t i = 0; i < buffers_.size(); ++i) {
     if (!buffers_[i].in_use) {
-      // TODO(ihf): Switch to a size calculation based on stride.
-      // Stride is filled out now but not more meaningful than size
-      // until wjia unifies VideoFrameBuffer and media::VideoFrame.
-      size_t size = std::min(static_cast<size_t>(buffers_[i].buffer->size()),
-          buffer->buffer_size);
-      memcpy(buffers_[i].data, buffer->memory_pointer, size);
+      DCHECK_EQ(frame->format(), media::VideoFrame::I420);
+      if (buffers_[i].buffer->size() <
+          media::VideoFrame::AllocationSize(frame->format(),
+                                            frame->coded_size())) {
+        // TODO(ihf): handle size mismatches gracefully here.
+        return;
+      }
+      uint8* dst = reinterpret_cast<uint8*>(buffers_[i].data);
+      COMPILE_ASSERT(media::VideoFrame::kYPlane == 0, y_plane_should_be_0);
+      COMPILE_ASSERT(media::VideoFrame::kUPlane == 1, u_plane_should_be_1);
+      COMPILE_ASSERT(media::VideoFrame::kVPlane == 2, v_plane_should_be_2);
+      for (size_t j = 0; j < media::VideoFrame::NumPlanes(frame->format());
+           ++j) {
+        const uint8* src = frame->data(j);
+        const size_t row_bytes = frame->row_bytes(j);
+        const size_t src_stride = frame->stride(j);
+        for (int k = 0; k < frame->rows(j); ++k) {
+          memcpy(dst, src, row_bytes);
+          dst += row_bytes;
+          src += src_stride;
+        }
+      }
       buffers_[i].in_use = true;
-      platform_video_capture_->FeedBuffer(buffer);
       host()->SendUnsolicitedReply(pp_resource(),
           PpapiPluginMsg_VideoCapture_OnBufferReady(i));
       return;
     }
   }
-
-  // No free slot, just discard the frame and tell the media layer it can
-  // re-use the buffer.
-  platform_video_capture_->FeedBuffer(buffer);
 }
 
 void PepperVideoCaptureHost::OnDeviceInfoReceived(
@@ -164,10 +175,8 @@ void PepperVideoCaptureHost::OnDeviceInfoReceived(
   };
   ReleaseBuffers();
 
-  // YUV 4:2:0
-  int uv_width = info.width / 2;
-  int uv_height = info.height / 2;
-  size_t size = info.width * info.height + 2 * uv_width * uv_height;
+  const size_t size = media::VideoFrame::AllocationSize(
+      media::VideoFrame::I420, gfx::Size(info.width, info.height));
 
   ppapi::proxy::ResourceMessageReplyParams params(pp_resource(), 0);
 

content/renderer/pepper/pepper_video_capture_host.h

@@ -44,9 +44,9 @@ class PepperVideoCaptureHost
   virtual void OnPaused(media::VideoCapture* capture) OVERRIDE;
   virtual void OnError(media::VideoCapture* capture, int error_code) OVERRIDE;
   virtual void OnRemoved(media::VideoCapture* capture) OVERRIDE;
-  virtual void OnBufferReady(
+  virtual void OnFrameReady(
       media::VideoCapture* capture,
-      scoped_refptr<media::VideoCapture::VideoFrameBuffer> buffer) OVERRIDE;
+      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE;
   virtual void OnDeviceInfoReceived(
       media::VideoCapture* capture,
       const media::VideoCaptureParams& device_info) OVERRIDE;

media/video/capture/video_capture.h

@@ -11,37 +11,14 @@
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "media/base/media_export.h"
-#include "media/base/video_frame.h"
 #include "media/video/capture/video_capture_types.h"
 
 namespace media {
 
+class VideoFrame;
+
 class MEDIA_EXPORT VideoCapture {
  public:
-  // TODO(wjia): consider merging with media::VideoFrame if possible.
-  class VideoFrameBuffer : public base::RefCountedThreadSafe<VideoFrameBuffer> {
-   public:
-    VideoFrameBuffer()
-        : width(0),
-          height(0),
-          stride(0),
-          buffer_size(0),
-          memory_pointer(NULL) {}
-
-    int width;
-    int height;
-    int stride;
-    size_t buffer_size;
-    uint8* memory_pointer;
-    base::Time timestamp;
-
-   private:
-    friend class base::RefCountedThreadSafe<VideoFrameBuffer>;
-    ~VideoFrameBuffer() {}
-
-    DISALLOW_COPY_AND_ASSIGN(VideoFrameBuffer);
-  };
-
   // TODO(wjia): add error codes.
   // TODO(wjia): support weak ptr.
   // Callbacks provided by client for notification of events.
@@ -64,8 +41,9 @@ class MEDIA_EXPORT VideoCapture {
     virtual void OnRemoved(VideoCapture* capture) = 0;
 
     // Notify client that a buffer is available.
-    virtual void OnBufferReady(VideoCapture* capture,
-                               scoped_refptr<VideoFrameBuffer> buffer) = 0;
+    virtual void OnFrameReady(
+        VideoCapture* capture,
+        const scoped_refptr<media::VideoFrame>& frame) = 0;
 
     // Notify client about device info.
     virtual void OnDeviceInfoReceived(
@@ -93,9 +71,6 @@ class MEDIA_EXPORT VideoCapture {
   // |handler| must remain valid until it has received |OnRemoved()|.
   virtual void StopCapture(EventHandler* handler) = 0;
 
-  // Feed buffer to video capture when done with it.
-  virtual void FeedBuffer(scoped_refptr<VideoFrameBuffer> buffer) = 0;
-
   virtual bool CaptureStarted() = 0;
   virtual int CaptureWidth() = 0;
   virtual int CaptureHeight() = 0;

media/video/capture/video_capture_proxy.cc

@@ -77,15 +77,16 @@ void VideoCaptureHandlerProxy::OnRemoved(VideoCapture* capture) {
       GetState(capture)));
 }
 
-void VideoCaptureHandlerProxy::OnBufferReady(
+void VideoCaptureHandlerProxy::OnFrameReady(
     VideoCapture* capture,
-    scoped_refptr<VideoCapture::VideoFrameBuffer> buffer) {
-  main_message_loop_->PostTask(FROM_HERE, base::Bind(
-      &VideoCaptureHandlerProxy::OnBufferReadyOnMainThread,
-      base::Unretained(this),
-      capture,
-      GetState(capture),
-      buffer));
+    const scoped_refptr<VideoFrame>& frame) {
+  main_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoCaptureHandlerProxy::OnFrameReadyOnMainThread,
+                 base::Unretained(this),
+                 capture,
+                 GetState(capture),
+                 frame));
 }
 
 void VideoCaptureHandlerProxy::OnDeviceInfoReceived(
@@ -135,12 +136,12 @@ void VideoCaptureHandlerProxy::OnRemovedOnMainThread(
   proxied_->OnRemoved(capture);
 }
 
-void VideoCaptureHandlerProxy::OnBufferReadyOnMainThread(
+void VideoCaptureHandlerProxy::OnFrameReadyOnMainThread(
     VideoCapture* capture,
     const VideoCaptureState& state,
-    scoped_refptr<VideoCapture::VideoFrameBuffer> buffer) {
+    const scoped_refptr<VideoFrame>& frame) {
   state_ = state;
-  proxied_->OnBufferReady(capture, buffer);
+  proxied_->OnFrameReady(capture, frame);
 }
 
 void VideoCaptureHandlerProxy::OnDeviceInfoReceivedOnMainThread(

media/video/capture/video_capture_proxy.h

@@ -50,9 +50,8 @@ class MEDIA_EXPORT VideoCaptureHandlerProxy
   virtual void OnPaused(VideoCapture* capture) OVERRIDE;
   virtual void OnError(VideoCapture* capture, int error_code) OVERRIDE;
   virtual void OnRemoved(VideoCapture* capture) OVERRIDE;
-  virtual void OnBufferReady(
-      VideoCapture* capture,
-      scoped_refptr<VideoCapture::VideoFrameBuffer> buffer) OVERRIDE;
+  virtual void OnFrameReady(VideoCapture* capture,
+                            const scoped_refptr<VideoFrame>& frame) OVERRIDE;
   virtual void OnDeviceInfoReceived(
       VideoCapture* capture,
       const VideoCaptureParams& device_info) OVERRIDE;
@@ -75,14 +74,12 @@ class MEDIA_EXPORT VideoCaptureHandlerProxy
   void OnRemovedOnMainThread(
       VideoCapture* capture,
       const VideoCaptureState& state);
-  void OnBufferReadyOnMainThread(
-      VideoCapture* capture,
-      const VideoCaptureState& state,
-      scoped_refptr<VideoCapture::VideoFrameBuffer> buffer);
-  void OnDeviceInfoReceivedOnMainThread(
-      VideoCapture* capture,
-      const VideoCaptureState& state,
-      const VideoCaptureParams& device_info);
+  void OnFrameReadyOnMainThread(VideoCapture* capture,
+                                const VideoCaptureState& state,
+                                const scoped_refptr<VideoFrame>& frame);
+  void OnDeviceInfoReceivedOnMainThread(VideoCapture* capture,
+                                        const VideoCaptureState& state,
+                                        const VideoCaptureParams& device_info);
 
   // Only accessed from main thread.
   VideoCapture::EventHandler* proxied_;