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

content/renderer/media/rtc_video_capturer.cc

 // Copyright (c) 2012 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/rtc_video_capturer.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 
 namespace content {
@@ skipping 22 matching lines @@
 
   media::VideoCaptureCapability cap;
   cap.width = capture_format.width;
   cap.height = capture_format.height;
   cap.frame_rate = capture_format.framerate();
   cap.color = media::PIXEL_FORMAT_I420;
 
   SetCaptureFormat(&capture_format);
 
   state_ = VIDEO_CAPTURE_STATE_STARTED;
-  start_time_ = base::Time::Now();
-  delegate_->StartCapture(cap,
+  start_time_delta_ = base::Time::Now() - base::Time::UnixEpoch();

[miu, 2013/09/12 03:01:58]

For consideration: Instead of doing this here, you might instead initialize
start_time_delta_ on the very first call to OnFrameCaptured().  This would
completely eliminate the read of the system clock.

Meaning, replace this line of code with:

  has_captured_first_frame_ = false;

and then in OnFrameCaptured(), just before assigning to
cricket_frame.elapsed_time:

  if (!has_captured_first_frame_) {
    start_time_delta_ = frame->GetTimestamp();
    has_captured_first_frame_ = true;
  }

+  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
   // cropped to meet the requirement if the camera returns a different
   // resolution than the |cap|.
   UpdateAspectRatio(cap.width, cap.height);
   return cricket::CS_STARTING;
 }
 
 void RtcVideoCapturer::Stop() {
@@ skipping 33 matching lines @@
   // Chrome does not support capability enumeration.
   // Use the desired format as the best format.
   best_format->width = desired.width;
   best_format->height = desired.height;
   best_format->fourcc = cricket::FOURCC_I420;
   best_format->interval = desired.interval;
   return true;
 }
 
 void RtcVideoCapturer::OnFrameCaptured(
-    const media::VideoCapture::VideoFrameBuffer& buf) {
+    const scoped_refptr<media::VideoFrame>& frame) {
   // 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 cricket_frame;
+  cricket_frame.width = frame->coded_size().width();
+  cricket_frame.height = frame->coded_size().height();
+  cricket_frame.fourcc = cricket::FOURCC_I420;
   // cricket::CapturedFrame time is in nanoseconds.
-  frame.elapsed_time = (buf.timestamp - start_time_).InMicroseconds() *
+  cricket_frame.elapsed_time =
+      (frame->GetTimestamp() - start_time_delta_).InMicroseconds() *
       base::Time::kNanosecondsPerMicrosecond;
-  frame.time_stamp =
-      (buf.timestamp - base::Time::UnixEpoch()).InMicroseconds() *
-      base::Time::kNanosecondsPerMicrosecond;
-  frame.data = buf.memory_pointer;
-  frame.pixel_height = 1;
-  frame.pixel_width = 1;
+  cricket_frame.time_stamp = frame->GetTimestamp().InMicroseconds() *
+                             base::Time::kNanosecondsPerMicrosecond;
+  // TODO(sheu): we assume contiguous layout of image planes.
+  cricket_frame.data = frame->data(0);
+  cricket_frame.data_size =
+      media::VideoFrame::AllocationSize(frame->format(), frame->coded_size());
+  cricket_frame.pixel_height = 1;
+  cricket_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);
+  TRACE_EVENT_INSTANT2(
+      "rtc_video_capturer",
+      "OnFrameCaptured",
+      TRACE_EVENT_SCOPE_THREAD,
+      "elapsed time",
+      cricket_frame.elapsed_time,
+      "timestamp_ms",
+      cricket_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, &cricket_frame);
 }
 
 void RtcVideoCapturer::OnStateChange(
     RtcVideoCaptureDelegate::CaptureState state) {
   cricket::CaptureState converted_state = cricket::CS_FAILED;
   DVLOG(3) << " RtcVideoCapturer::OnStateChange " << state;
   switch (state) {
     case RtcVideoCaptureDelegate::CAPTURE_STOPPED:
       converted_state = cricket::CS_STOPPED;
       break;
     case RtcVideoCaptureDelegate::CAPTURE_RUNNING:
       converted_state = cricket::CS_RUNNING;
       break;
     case RtcVideoCaptureDelegate::CAPTURE_FAILED:
       // TODO(perkj): Update the comments in the the definition of
       // cricket::CS_FAILED. According to the comments, cricket::CS_FAILED
       // means that the capturer failed to start. But here and in libjingle it
       // is also used if an error occur during capturing.
       converted_state = cricket::CS_FAILED;
       break;
     default:
       NOTREACHED();
       break;
   }
   SignalStateChange(this, converted_state);
 }
 
 }  // namespace content