Update I420Buffer to new VideoFrameBuffer interface

webrtc/api/video/i420_buffer.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/api/video/i420_buffer.h"
@@ skipping 59 matching lines @@
                                                   int height,
                                                   int stride_y,
                                                   int stride_u,
                                                   int stride_v) {
   return new rtc::RefCountedObject<I420Buffer>(
       width, height, stride_y, stride_u, stride_v);
 }
 
 // static
 rtc::scoped_refptr<I420Buffer> I420Buffer::Copy(
-    const VideoFrameBuffer& source) {
+    const I420BufferInterface& source) {
   return Copy(source.width(), source.height(),
               source.DataY(), source.StrideY(),
               source.DataU(), source.StrideU(),
               source.DataV(), source.StrideV());
 }
 
 // static
 rtc::scoped_refptr<I420Buffer> I420Buffer::Copy(
       int width, int height,
       const uint8_t* data_y, int stride_y,
       const uint8_t* data_u, int stride_u,
       const uint8_t* data_v, int stride_v) {
   // Note: May use different strides than the input data.
   rtc::scoped_refptr<I420Buffer> buffer = Create(width, height);
   RTC_CHECK_EQ(0, libyuv::I420Copy(data_y, stride_y,
                                    data_u, stride_u,
                                    data_v, stride_v,
                                    buffer->MutableDataY(), buffer->StrideY(),
                                    buffer->MutableDataU(), buffer->StrideU(),
                                    buffer->MutableDataV(), buffer->StrideV(),
                                    width, height));
   return buffer;
 }
 
 // static
 rtc::scoped_refptr<I420Buffer> I420Buffer::Rotate(
-    const VideoFrameBuffer& src, VideoRotation rotation) {
+    const I420BufferInterface& src,
+    VideoRotation rotation) {
   RTC_CHECK(src.DataY());
   RTC_CHECK(src.DataU());
   RTC_CHECK(src.DataV());
 
   int rotated_width = src.width();
   int rotated_height = src.height();
   if (rotation == webrtc::kVideoRotation_90 ||
       rotation == webrtc::kVideoRotation_270) {
     std::swap(rotated_width, rotated_height);
   }
@@ skipping 58 matching lines @@
 
 // static
 void I420Buffer::SetBlack(I420Buffer* buffer) {
   RTC_CHECK(libyuv::I420Rect(buffer->MutableDataY(), buffer->StrideY(),
                              buffer->MutableDataU(), buffer->StrideU(),
                              buffer->MutableDataV(), buffer->StrideV(),
                              0, 0, buffer->width(), buffer->height(),
                              0, 128, 128) == 0);
 }
 
-void I420Buffer::CropAndScaleFrom(
-    const VideoFrameBuffer& src,
-    int offset_x,
-    int offset_y,
-    int crop_width,
-    int crop_height) {
+void I420Buffer::CropAndScaleFrom(const I420BufferInterface& src,
+                                  int offset_x,
+                                  int offset_y,
+                                  int crop_width,
+                                  int crop_height) {
   RTC_CHECK_LE(crop_width, src.width());
   RTC_CHECK_LE(crop_height, src.height());
   RTC_CHECK_LE(crop_width + offset_x, src.width());
   RTC_CHECK_LE(crop_height + offset_y, src.height());
   RTC_CHECK_GE(offset_x, 0);
   RTC_CHECK_GE(offset_y, 0);
 
   // Make sure offset is even so that u/v plane becomes aligned.
   const int uv_offset_x = offset_x / 2;
   const int uv_offset_y = offset_y / 2;
@@ skipping 11 matching lines @@
                               v_plane, src.StrideV(),
                               crop_width, crop_height,
                               MutableDataY(), StrideY(),
                               MutableDataU(), StrideU(),
                               MutableDataV(), StrideV(),
                               width(), height(), libyuv::kFilterBox);
 
   RTC_DCHECK_EQ(res, 0);
 }
 
-void I420Buffer::CropAndScaleFrom(
-    const VideoFrameBuffer& src) {
+void I420Buffer::CropAndScaleFrom(const I420BufferInterface& src) {
   const int crop_width =
       std::min(src.width(), width() * src.height() / height());
   const int crop_height =
       std::min(src.height(), height() * src.width() / width());
 
   CropAndScaleFrom(
       src,
       (src.width() - crop_width) / 2, (src.height() - crop_height) / 2,
       crop_width, crop_height);
 }
 
-void I420Buffer::ScaleFrom(const VideoFrameBuffer& src) {
+void I420Buffer::ScaleFrom(const I420BufferInterface& src) {
   CropAndScaleFrom(src, 0, 0, src.width(), src.height());
 }
 
 }  // namespace webrtc