diff --git a/webrtc/common_video/corevideo_frame_buffer.cc b/webrtc/common_video/corevideo_frame_buffer.cc
index a58ddc7..3245bf5 100644
--- a/webrtc/common_video/corevideo_frame_buffer.cc
+++ b/webrtc/common_video/corevideo_frame_buffer.cc
@@ -35,7 +35,7 @@
   size_t width = CVPixelBufferGetWidthOfPlane(pixel_buffer_, 0);
   size_t height = CVPixelBufferGetHeightOfPlane(pixel_buffer_, 0);
   // TODO(tkchin): Use a frame buffer pool.
-  rtc::scoped_refptr<webrtc::VideoFrameBuffer> buffer =
+  rtc::scoped_refptr<webrtc::I420Buffer> buffer =
       new rtc::RefCountedObject<webrtc::I420Buffer>(width, height);
   CVPixelBufferLockBaseAddress(pixel_buffer_, kCVPixelBufferLock_ReadOnly);
   const uint8_t* src_y = static_cast<const uint8_t*>(
diff --git a/webrtc/common_video/i420_buffer_pool_unittest.cc b/webrtc/common_video/i420_buffer_pool_unittest.cc
index 3e795db..3307539 100644
--- a/webrtc/common_video/i420_buffer_pool_unittest.cc
+++ b/webrtc/common_video/i420_buffer_pool_unittest.cc
@@ -52,7 +52,7 @@
 }
 
 TEST(TestI420BufferPool, FrameValidAfterPoolDestruction) {
-  rtc::scoped_refptr<VideoFrameBuffer> buffer;
+  rtc::scoped_refptr<I420Buffer> buffer;
   {
     I420BufferPool pool;
     buffer = pool.CreateBuffer(16, 16);
diff --git a/webrtc/common_video/i420_video_frame_unittest.cc b/webrtc/common_video/i420_video_frame_unittest.cc
index 406dbd3..f9d46ef 100644
--- a/webrtc/common_video/i420_video_frame_unittest.cc
+++ b/webrtc/common_video/i420_video_frame_unittest.cc
@@ -162,16 +162,14 @@
   EXPECT_EQ(kRotation, small_frame.rotation());
 
   // Frame of larger dimensions.
-  small_frame.CreateEmptyFrame(width, height,
-                               stride_y, stride_u, stride_v);
-  memset(small_frame.video_frame_buffer()->MutableDataY(), 1,
-         small_frame.allocated_size(kYPlane));
-  memset(small_frame.video_frame_buffer()->MutableDataU(), 2,
-         small_frame.allocated_size(kUPlane));
-  memset(small_frame.video_frame_buffer()->MutableDataV(), 3,
-         small_frame.allocated_size(kVPlane));
-  big_frame.CopyFrame(small_frame);
-  EXPECT_TRUE(test::FramesEqual(small_frame, big_frame));
+  rtc::scoped_refptr<I420Buffer> buffer =
+      I420Buffer::Create(width, height, stride_y, stride_u, stride_v);
+  memset(buffer->MutableDataY(), 1, width * height);
+  memset(buffer->MutableDataU(), 2, ((height + 1) / 2) * stride_u);
+  memset(buffer->MutableDataV(), 3, ((height + 1) / 2) * stride_u);
+  VideoFrame other_frame(buffer, 0, 0, webrtc::kVideoRotation_0);
+  big_frame.CopyFrame(other_frame);
+  EXPECT_TRUE(test::FramesEqual(other_frame, big_frame));
 }
 
 TEST(TestVideoFrame, ShallowCopy) {
diff --git a/webrtc/common_video/include/video_frame_buffer.h b/webrtc/common_video/include/video_frame_buffer.h
index 6743970..ae7855f 100644
--- a/webrtc/common_video/include/video_frame_buffer.h
+++ b/webrtc/common_video/include/video_frame_buffer.h
@@ -45,12 +45,6 @@
   virtual const uint8_t* DataU() const = 0;
   virtual const uint8_t* DataV() const = 0;
 
-  // TODO(nisse): Move MutableData methods to the I420Buffer subclass.
-  // Non-const data access.
-  virtual uint8_t* MutableDataY();
-  virtual uint8_t* MutableDataU();
-  virtual uint8_t* MutableDataV();
-
   // Returns the number of bytes between successive rows for a given plane.
   virtual int StrideY() const = 0;
   virtual int StrideU() const = 0;
@@ -98,9 +92,9 @@
   const uint8_t* DataU() const override;
   const uint8_t* DataV() const override;
 
-  uint8_t* MutableDataY() override;
-  uint8_t* MutableDataU() override;
-  uint8_t* MutableDataV() override;
+  uint8_t* MutableDataY();
+  uint8_t* MutableDataU();
+  uint8_t* MutableDataV();
   int StrideY() const override;
   int StrideU() const override;
   int StrideV() const override;
diff --git a/webrtc/common_video/libyuv/include/webrtc_libyuv.h b/webrtc/common_video/libyuv/include/webrtc_libyuv.h
index 699a626..f8cd470 100644
--- a/webrtc/common_video/libyuv/include/webrtc_libyuv.h
+++ b/webrtc/common_video/libyuv/include/webrtc_libyuv.h
@@ -69,6 +69,7 @@
 //                    already open for writing.
 // Return value: 0 if OK, < 0 otherwise.
 int PrintVideoFrame(const VideoFrame& frame, FILE* file);
+int PrintVideoFrame(const VideoFrameBuffer& frame, FILE* file);
 
 // Extract buffer from VideoFrame or VideoFrameBuffer (consecutive
 // planes, no stride)
@@ -92,11 +93,13 @@
 //   - sample_size      : Required only for the parsing of MJPG (set to 0 else).
 //   - rotate           : Rotation mode of output image.
 // Output:
-//   - dst_frame        : Reference to a destination frame.
+//   - dst_buffer       : Reference to a destination frame buffer.
 // Return value: 0 if OK, < 0 otherwise.
 
-// TODO(nisse): Deprecated, see
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=5921.
+// TODO(nisse): Delete this wrapper, and let users call libyuv directly. Most
+// calls pass |src_video_type| == kI420, and should use libyuv::I420Copy. The
+// only exception at the time of this writing is
+// VideoCaptureImpl::IncomingFrame, which still needs libyuv::ConvertToI420.
 int ConvertToI420(VideoType src_video_type,
                   const uint8_t* src_frame,
                   int crop_x,
@@ -105,7 +108,7 @@
                   int src_height,
                   size_t sample_size,
                   VideoRotation rotation,
-                  VideoFrame* dst_frame);
+                  I420Buffer* dst_buffer);
 
 // Convert From I420
 // Input:
diff --git a/webrtc/common_video/libyuv/libyuv_unittest.cc b/webrtc/common_video/libyuv/libyuv_unittest.cc
index ab36559..c6ca212 100644
--- a/webrtc/common_video/libyuv/libyuv_unittest.cc
+++ b/webrtc/common_video/libyuv/libyuv_unittest.cc
@@ -95,21 +95,20 @@
 
   double psnr = 0.0;
 
-  VideoFrame res_i420_frame;
-  res_i420_frame.CreateEmptyFrame(width_, height_, width_,
-                                               (width_ + 1) / 2,
-                                               (width_ + 1) / 2);
+  rtc::scoped_refptr<I420Buffer> res_i420_buffer = I420Buffer::Create(
+      width_, height_, width_, (width_ + 1) / 2, (width_ + 1) / 2);
+
   printf("\nConvert #%d I420 <-> I420 \n", j);
   std::unique_ptr<uint8_t[]> out_i420_buffer(new uint8_t[frame_length_]);
-  EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0,
-                               out_i420_buffer.get()));
+  EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0, out_i420_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kI420, out_i420_buffer.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
+                             height_, 0, kVideoRotation_0,
+                             res_i420_buffer.get()));
 
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
   EXPECT_EQ(48.0, psnr);
   j++;
 
@@ -119,17 +118,18 @@
   int stride_y = 0;
   int stride_uv = 0;
   Calc16ByteAlignedStride(width_, &stride_y, &stride_uv);
-  res_i420_frame.CreateEmptyFrame(width_, height_, stride_y,
-                                  stride_uv, stride_uv);
+  res_i420_buffer =
+      I420Buffer::Create(width_, height_, stride_y, stride_uv, stride_uv);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kRGB24, 0, res_rgb_buffer2.get()));
 
   EXPECT_EQ(0, ConvertToI420(kRGB24, res_rgb_buffer2.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
+                             height_, 0, kVideoRotation_0,
+                             res_i420_buffer.get()));
 
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
 
   // Optimization Speed- quality trade-off => 45 dB only (platform dependant).
   EXPECT_GT(ceil(psnr), 44);
@@ -137,44 +137,47 @@
 
   printf("\nConvert #%d I420 <-> UYVY\n", j);
   std::unique_ptr<uint8_t[]> out_uyvy_buffer(new uint8_t[width_ * height_ * 2]);
-  EXPECT_EQ(0, ConvertFromI420(orig_frame_,  kUYVY, 0, out_uyvy_buffer.get()));
+  EXPECT_EQ(0, ConvertFromI420(orig_frame_, kUYVY, 0, out_uyvy_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kUYVY, out_uyvy_buffer.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
+                             height_, 0, kVideoRotation_0,
+                             res_i420_buffer.get()));
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
   EXPECT_EQ(48.0, psnr);
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
   j++;
 
   printf("\nConvert #%d I420 <-> YUY2\n", j);
   std::unique_ptr<uint8_t[]> out_yuy2_buffer(new uint8_t[width_ * height_ * 2]);
-  EXPECT_EQ(0, ConvertFromI420(orig_frame_,  kYUY2, 0, out_yuy2_buffer.get()));
+  EXPECT_EQ(0, ConvertFromI420(orig_frame_, kYUY2, 0, out_yuy2_buffer.get()));
 
   EXPECT_EQ(0, ConvertToI420(kYUY2, out_yuy2_buffer.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
+                             height_, 0,
+                             kVideoRotation_0, res_i420_buffer.get()));
 
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
 
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
   EXPECT_EQ(48.0, psnr);
+
   printf("\nConvert #%d I420 <-> RGB565\n", j);
   std::unique_ptr<uint8_t[]> out_rgb565_buffer(
       new uint8_t[width_ * height_ * 2]);
-  EXPECT_EQ(0, ConvertFromI420(orig_frame_, kRGB565, 0,
-                               out_rgb565_buffer.get()));
+  EXPECT_EQ(0,
+            ConvertFromI420(orig_frame_, kRGB565, 0, out_rgb565_buffer.get()));
 
   EXPECT_EQ(0, ConvertToI420(kRGB565, out_rgb565_buffer.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
-
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+                             height_, 0,
+                             kVideoRotation_0, res_i420_buffer.get()));
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
   j++;
 
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
   // TODO(leozwang) Investigate the right psnr should be set for I420ToRGB565,
   // Another example is I420ToRGB24, the psnr is 44
   // TODO(mikhal): Add psnr for RGB565, 1555, 4444, convert to ARGB.
@@ -183,18 +186,20 @@
   printf("\nConvert #%d I420 <-> ARGB8888\n", j);
   std::unique_ptr<uint8_t[]> out_argb8888_buffer(
       new uint8_t[width_ * height_ * 4]);
-  EXPECT_EQ(0, ConvertFromI420(orig_frame_, kARGB, 0,
-                               out_argb8888_buffer.get()));
+  EXPECT_EQ(0,
+            ConvertFromI420(orig_frame_, kARGB, 0, out_argb8888_buffer.get()));
 
   EXPECT_EQ(0, ConvertToI420(kARGB, out_argb8888_buffer.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
+                             height_, 0, kVideoRotation_0,
+                             res_i420_buffer.get()));
 
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
 
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
-  // TODO(leozwang) Investigate the right psnr should be set for I420ToARGB8888,
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
+  // TODO(leozwang) Investigate the right psnr should be set for
+  // I420ToARGB8888,
   EXPECT_GT(ceil(psnr), 42);
 
   ASSERT_EQ(0, fclose(output_file));
@@ -209,49 +214,48 @@
 
   double psnr = 0.0;
 
-  VideoFrame res_i420_frame;
   int stride_y = 0;
   int stride_uv = 0;
   Calc16ByteAlignedStride(width_, &stride_y, &stride_uv);
-  res_i420_frame.CreateEmptyFrame(width_, height_,
-                                  stride_y, stride_uv, stride_uv);
+
+  rtc::scoped_refptr<I420Buffer> res_i420_buffer =
+      I420Buffer::Create(width_, height_, stride_y, stride_uv, stride_uv);
   std::unique_ptr<uint8_t[]> out_i420_buffer(new uint8_t[frame_length_]);
   EXPECT_EQ(0, ConvertFromI420(orig_frame_, kI420, 0,
                                out_i420_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kI420, out_i420_buffer.get(), 0, 0, width_,
-                             height_, 0, kVideoRotation_0, &res_i420_frame));
+                             height_, 0, kVideoRotation_0,
+                             res_i420_buffer.get()));
 
-  if (PrintVideoFrame(res_i420_frame, output_file) < 0) {
+  if (PrintVideoFrame(*res_i420_buffer, output_file) < 0) {
     return;
   }
-  psnr = I420PSNR(&orig_frame_, &res_i420_frame);
+  psnr = I420PSNR(*orig_frame_.video_frame_buffer(), *res_i420_buffer);
   EXPECT_EQ(48.0, psnr);
 }
 
 
 TEST_F(TestLibYuv, RotateTest) {
-  // Use ConvertToI420 for multiple roatations - see that nothing breaks, all
+  // Use ConvertToI420 for multiple rotations - see that nothing breaks, all
   // memory is properly allocated and end result is equal to the starting point.
-  VideoFrame rotated_res_i420_frame;
   int rotated_width = height_;
   int rotated_height = width_;
   int stride_y;
   int stride_uv;
   Calc16ByteAlignedStride(rotated_width, &stride_y, &stride_uv);
-  rotated_res_i420_frame.CreateEmptyFrame(rotated_width,
-                                          rotated_height,
-                                          stride_y,
-                                          stride_uv,
-                                          stride_uv);
+  rtc::scoped_refptr<I420Buffer> rotated_res_i420_buffer = I420Buffer::Create(
+      rotated_width, rotated_height, stride_y, stride_uv, stride_uv);
   EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0, width_, height_,
-                             0, kVideoRotation_90, &rotated_res_i420_frame));
+                             0, kVideoRotation_90,
+                             rotated_res_i420_buffer.get()));
   EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0, width_, height_,
-                             0, kVideoRotation_270, &rotated_res_i420_frame));
-  rotated_res_i420_frame.CreateEmptyFrame(width_, height_,
-                                          width_, (width_ + 1) / 2,
-                                          (width_ + 1) / 2);
+                             0, kVideoRotation_270,
+                             rotated_res_i420_buffer.get()));
+  rotated_res_i420_buffer = I420Buffer::Create(
+      width_, height_, width_, (width_ + 1) / 2, (width_ + 1) / 2);
   EXPECT_EQ(0, ConvertToI420(kI420, orig_buffer_.get(), 0, 0, width_, height_,
-                             0, kVideoRotation_180, &rotated_res_i420_frame));
+                             0, kVideoRotation_180,
+                             rotated_res_i420_buffer.get()));
 }
 
 }  // namespace webrtc
diff --git a/webrtc/common_video/libyuv/webrtc_libyuv.cc b/webrtc/common_video/libyuv/webrtc_libyuv.cc
index d05b644..6a7ba15 100644
--- a/webrtc/common_video/libyuv/webrtc_libyuv.cc
+++ b/webrtc/common_video/libyuv/webrtc_libyuv.cc
@@ -103,33 +103,35 @@
 }
 
 // TODO(nisse): Belongs with the test code?
-int PrintVideoFrame(const VideoFrame& frame, FILE* file) {
-  if (file == NULL)
-    return -1;
-  if (frame.IsZeroSize())
-    return -1;
-  int width = frame.video_frame_buffer()->width();
-  int height = frame.video_frame_buffer()->height();
+int PrintVideoFrame(const VideoFrameBuffer& frame, FILE* file) {
+  int width = frame.width();
+  int height = frame.height();
   int chroma_width = (width + 1) / 2;
   int chroma_height = (height + 1) / 2;
 
-  if (PrintPlane(frame.video_frame_buffer()->DataY(), width, height,
-                 frame.video_frame_buffer()->StrideY(), file) < 0) {
+  if (PrintPlane(frame.DataY(), width, height,
+                 frame.StrideY(), file) < 0) {
     return -1;
   }
-  if (PrintPlane(frame.video_frame_buffer()->DataU(),
+  if (PrintPlane(frame.DataU(),
                  chroma_width, chroma_height,
-                 frame.video_frame_buffer()->StrideU(), file) < 0) {
+                 frame.StrideU(), file) < 0) {
     return -1;
   }
-  if (PrintPlane(frame.video_frame_buffer()->DataV(),
+  if (PrintPlane(frame.DataV(),
                  chroma_width, chroma_height,
-                 frame.video_frame_buffer()->StrideV(), file) < 0) {
+                 frame.StrideV(), file) < 0) {
     return -1;
   }
   return 0;
 }
 
+int PrintVideoFrame(const VideoFrame& frame, FILE* file) {
+  if (frame.IsZeroSize())
+    return -1;
+  return PrintVideoFrame(*frame.video_frame_buffer(), file);
+}
+
 int ExtractBuffer(const rtc::scoped_refptr<VideoFrameBuffer>& input_frame,
                   size_t size,
                   uint8_t* buffer) {
@@ -249,23 +251,19 @@
                   int src_height,
                   size_t sample_size,
                   VideoRotation rotation,
-                  VideoFrame* dst_frame) {
-  int dst_width = dst_frame->width();
-  int dst_height = dst_frame->height();
+                  I420Buffer* dst_buffer) {
+  int dst_width = dst_buffer->width();
+  int dst_height = dst_buffer->height();
   // LibYuv expects pre-rotation values for dst.
   // Stride values should correspond to the destination values.
   if (rotation == kVideoRotation_90 || rotation == kVideoRotation_270) {
-    dst_width = dst_frame->height();
-    dst_height = dst_frame->width();
+    std::swap(dst_width, dst_height);
   }
   return libyuv::ConvertToI420(
       src_frame, sample_size,
-      dst_frame->video_frame_buffer()->MutableDataY(),
-      dst_frame->video_frame_buffer()->StrideY(),
-      dst_frame->video_frame_buffer()->MutableDataU(),
-      dst_frame->video_frame_buffer()->StrideU(),
-      dst_frame->video_frame_buffer()->MutableDataV(),
-      dst_frame->video_frame_buffer()->StrideV(),
+      dst_buffer->MutableDataY(), dst_buffer->StrideY(),
+      dst_buffer->MutableDataU(), dst_buffer->StrideU(),
+      dst_buffer->MutableDataV(), dst_buffer->StrideV(),
       crop_x, crop_y,
       src_width, src_height,
       dst_width, dst_height,
diff --git a/webrtc/common_video/video_frame.cc b/webrtc/common_video/video_frame.cc
index e00ca27..4b29be9 100644
--- a/webrtc/common_video/video_frame.cc
+++ b/webrtc/common_video/video_frame.cc
@@ -87,10 +87,18 @@
   const int expected_size_y = height * stride_y;
   const int expected_size_u = half_height * stride_u;
   const int expected_size_v = half_height * stride_v;
-  CreateEmptyFrame(width, height, stride_y, stride_u, stride_v);
-  memcpy(video_frame_buffer_->MutableDataY(), buffer_y, expected_size_y);
-  memcpy(video_frame_buffer_->MutableDataU(), buffer_u, expected_size_u);
-  memcpy(video_frame_buffer_->MutableDataV(), buffer_v, expected_size_v);
+  // Allocate a new buffer.
+  rtc::scoped_refptr<I420Buffer> buffer_ =
+      I420Buffer::Create(width, height, stride_y, stride_u, stride_v);
+
+  memcpy(buffer_->MutableDataY(), buffer_y, expected_size_y);
+  memcpy(buffer_->MutableDataU(), buffer_u, expected_size_u);
+  memcpy(buffer_->MutableDataV(), buffer_v, expected_size_v);
+
+  video_frame_buffer_ = buffer_;
+  timestamp_rtp_ = 0;
+  ntp_time_ms_ = 0;
+  timestamp_us_ = 0;
   rotation_ = rotation;
 }
 
diff --git a/webrtc/common_video/video_frame_buffer.cc b/webrtc/common_video/video_frame_buffer.cc
index 2d7e7f4..dbb2743 100644
--- a/webrtc/common_video/video_frame_buffer.cc
+++ b/webrtc/common_video/video_frame_buffer.cc
@@ -31,19 +31,6 @@
 
 }  // namespace
 
-uint8_t* VideoFrameBuffer::MutableDataY() {
-  RTC_NOTREACHED();
-  return nullptr;
-}
-uint8_t* VideoFrameBuffer::MutableDataU() {
-  RTC_NOTREACHED();
-  return nullptr;
-}
-uint8_t* VideoFrameBuffer::MutableDataV() {
-  RTC_NOTREACHED();
-  return nullptr;
-}
-
 VideoFrameBuffer::~VideoFrameBuffer() {}
 
 I420Buffer::I420Buffer(int width, int height)
diff --git a/webrtc/media/base/videoframe_unittest.h b/webrtc/media/base/videoframe_unittest.h
index 9658f87..42936bb 100644
--- a/webrtc/media/base/videoframe_unittest.h
+++ b/webrtc/media/base/videoframe_unittest.h
@@ -453,7 +453,6 @@
   static bool IsEqual(const cricket::VideoFrame& frame,
                       int width,
                       int height,
-                      int64_t timestamp_us,
                       const uint8_t* y,
                       uint32_t ypitch,
                       const uint8_t* u,
@@ -462,7 +461,6 @@
                       uint32_t vpitch,
                       int max_error) {
     return IsSize(frame, width, height) &&
-           frame.timestamp_us() == timestamp_us &&
            IsPlaneEqual("y", frame.video_frame_buffer()->DataY(),
                         frame.video_frame_buffer()->StrideY(), y, ypitch,
                         static_cast<uint32_t>(width),
@@ -480,15 +478,25 @@
   static bool IsEqual(const cricket::VideoFrame& frame1,
                       const cricket::VideoFrame& frame2,
                       int max_error) {
-    return IsEqual(frame1,
+    return frame1.timestamp_us() == frame2.timestamp_us() &&
+           IsEqual(frame1,
                    frame2.width(), frame2.height(),
-                   frame2.timestamp_us(),
                    frame2.video_frame_buffer()->DataY(),
                    frame2.video_frame_buffer()->StrideY(),
                    frame2.video_frame_buffer()->DataU(),
                    frame2.video_frame_buffer()->StrideU(),
                    frame2.video_frame_buffer()->DataV(),
-                   frame2.video_frame_buffer()->StrideV(),
+                   frame2.video_frame_buffer()->StrideV(), max_error);
+  }
+
+  static bool IsEqual(
+      const cricket::VideoFrame& frame1,
+      const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& buffer,
+      int max_error) {
+    return IsEqual(frame1, buffer->width(), buffer->height(),
+                   buffer->DataY(), buffer->StrideY(),
+                   buffer->DataU(), buffer->StrideU(),
+                   buffer->DataV(), buffer->StrideV(),
                    max_error);
   }
 
@@ -497,10 +505,10 @@
                               int hcrop, int vcrop, int max_error) {
     return frame1.width() <= frame2.width() &&
            frame1.height() <= frame2.height() &&
+           frame1.timestamp_us() == frame2.timestamp_us() &&
            IsEqual(frame1,
                    frame2.width() - hcrop * 2,
                    frame2.height() - vcrop * 2,
-                   frame2.timestamp_us(),
                    frame2.video_frame_buffer()->DataY()
                        + vcrop * frame2.video_frame_buffer()->StrideY()
                        + hcrop,
@@ -539,8 +547,8 @@
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* u = y + kWidth * kHeight;
     const uint8_t* v = u + kWidth * kHeight / 4;
-    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
-                        kWidth / 2, v, kWidth / 2, 0));
+    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, y, kWidth, u, kWidth / 2, v,
+                        kWidth / 2, 0));
   }
 
   // Test constructing an image from a YV12 buffer.
@@ -554,8 +562,8 @@
     const uint8_t* y = reinterpret_cast<uint8_t*>(ms.get()->GetBuffer());
     const uint8_t* v = y + kWidth * kHeight;
     const uint8_t* u = v + kWidth * kHeight / 4;
-    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, 0, y, kWidth, u,
-                        kWidth / 2, v, kWidth / 2, 0));
+    EXPECT_TRUE(IsEqual(frame, kWidth, kHeight, y, kWidth, u, kWidth / 2, v,
+                        kWidth / 2, 0));
   }
 
   // Test constructing an image from a I422 buffer.
@@ -772,7 +780,8 @@
 // Macro to help test different rotations
 #define TEST_MIRROR(FOURCC, BPP)                                               \
   void Construct##FOURCC##Mirror() {                                           \
-    T frame1, frame2, frame3;                                                  \
+    T frame1, frame2;                                                          \
+    rtc::scoped_refptr<webrtc::I420Buffer> res_buffer;                         \
     std::unique_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
@@ -788,21 +797,18 @@
                             data_size, 0, webrtc::kVideoRotation_0));          \
     int width_rotate = frame1.width();                                         \
     int height_rotate = frame1.height();                                       \
-    frame3.InitToEmptyBuffer(width_rotate, height_rotate);                     \
+    res_buffer = webrtc::I420Buffer::Create(width_rotate, height_rotate);      \
     libyuv::I420Mirror(frame2.video_frame_buffer()->DataY(),                   \
                        frame2.video_frame_buffer()->StrideY(),                 \
                        frame2.video_frame_buffer()->DataU(),                   \
                        frame2.video_frame_buffer()->StrideU(),                 \
                        frame2.video_frame_buffer()->DataV(),                   \
                        frame2.video_frame_buffer()->StrideV(),                 \
-                       frame3.video_frame_buffer()->MutableDataY(),            \
-                       frame3.video_frame_buffer()->StrideY(),                 \
-                       frame3.video_frame_buffer()->MutableDataU(),            \
-                       frame3.video_frame_buffer()->StrideU(),                 \
-                       frame3.video_frame_buffer()->MutableDataV(),            \
-                       frame3.video_frame_buffer()->StrideV(), kWidth,         \
-                       kHeight);                                               \
-    EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
+                       res_buffer->MutableDataY(), res_buffer->StrideY(),      \
+                       res_buffer->MutableDataU(), res_buffer->StrideU(),      \
+                       res_buffer->MutableDataV(), res_buffer->StrideV(),      \
+                       kWidth, kHeight);                                       \
+    EXPECT_TRUE(IsEqual(frame1, res_buffer, 0));                               \
   }
 
   TEST_MIRROR(I420, 420)
@@ -810,7 +816,8 @@
 // Macro to help test different rotations
 #define TEST_ROTATE(FOURCC, BPP, ROTATE)                                       \
   void Construct##FOURCC##Rotate##ROTATE() {                                   \
-    T frame1, frame2, frame3;                                                  \
+    T frame1, frame2;                                                          \
+    rtc::scoped_refptr<webrtc::I420Buffer> res_buffer;                         \
     std::unique_ptr<rtc::MemoryStream> ms(                                     \
         CreateYuvSample(kWidth, kHeight, BPP));                                \
     ASSERT_TRUE(ms.get() != NULL);                                             \
@@ -826,21 +833,18 @@
                             data_size, 0, webrtc::kVideoRotation_0));          \
     int width_rotate = frame1.width();                                         \
     int height_rotate = frame1.height();                                       \
-    frame3.InitToEmptyBuffer(width_rotate, height_rotate);                     \
+    res_buffer = webrtc::I420Buffer::Create(width_rotate, height_rotate);      \
     libyuv::I420Rotate(frame2.video_frame_buffer()->DataY(),                   \
                        frame2.video_frame_buffer()->StrideY(),                 \
                        frame2.video_frame_buffer()->DataU(),                   \
                        frame2.video_frame_buffer()->StrideU(),                 \
                        frame2.video_frame_buffer()->DataV(),                   \
                        frame2.video_frame_buffer()->StrideV(),                 \
-                       frame3.video_frame_buffer()->MutableDataY(),            \
-                       frame3.video_frame_buffer()->StrideY(),                 \
-                       frame3.video_frame_buffer()->MutableDataU(),            \
-                       frame3.video_frame_buffer()->StrideU(),                 \
-                       frame3.video_frame_buffer()->MutableDataV(),            \
-                       frame3.video_frame_buffer()->StrideV(), kWidth,         \
-                       kHeight, libyuv::kRotate##ROTATE);                      \
-    EXPECT_TRUE(IsEqual(frame1, frame3, 0));                                   \
+                       res_buffer->MutableDataY(), res_buffer->StrideY(),      \
+                       res_buffer->MutableDataU(), res_buffer->StrideU(),      \
+                       res_buffer->MutableDataV(), res_buffer->StrideV(),      \
+                       kWidth, kHeight, libyuv::kRotate##ROTATE);              \
+    EXPECT_TRUE(IsEqual(frame1, res_buffer, 0));                               \
   }
 
   // Test constructing an image with rotation.
@@ -944,7 +948,7 @@
     const uint8_t* y = pixel;
     const uint8_t* u = y + 1;
     const uint8_t* v = u + 1;
-    EXPECT_TRUE(IsEqual(frame, 1, 1, 0, y, 1, u, 1, v, 1, 0));
+    EXPECT_TRUE(IsEqual(frame, 1, 1, y, 1, u, 1, v, 1, 0));
   }
 
   // Test 5 pixel edge case image.
diff --git a/webrtc/media/engine/webrtcvideoengine2_unittest.cc b/webrtc/media/engine/webrtcvideoengine2_unittest.cc
index b9c6604..c81fd88 100644
--- a/webrtc/media/engine/webrtcvideoengine2_unittest.cc
+++ b/webrtc/media/engine/webrtcvideoengine2_unittest.cc
@@ -66,17 +66,13 @@
       cricket::kRtcpFbParamCcm, cricket::kRtcpFbCcmParamFir)));
 }
 
-static void CreateBlackFrame(webrtc::VideoFrame* video_frame,
-                             int width,
-                             int height) {
-  video_frame->CreateEmptyFrame(
-      width, height, width, (width + 1) / 2, (width + 1) / 2);
-  memset(video_frame->video_frame_buffer()->MutableDataY(), 16,
-         video_frame->allocated_size(webrtc::kYPlane));
-  memset(video_frame->video_frame_buffer()->MutableDataU(), 128,
-         video_frame->allocated_size(webrtc::kUPlane));
-  memset(video_frame->video_frame_buffer()->MutableDataV(), 128,
-         video_frame->allocated_size(webrtc::kVPlane));
+static rtc::scoped_refptr<webrtc::VideoFrameBuffer> CreateBlackFrameBuffer(
+    int width,
+    int height) {
+  rtc::scoped_refptr<webrtc::I420Buffer> buffer =
+      webrtc::I420Buffer::Create(width, height);
+  buffer->SetToBlack();
+  return buffer;
 }
 
 void VerifySendStreamHasRtxTypes(const webrtc::VideoSendStream::Config& config,
@@ -2204,9 +2200,9 @@
   cricket::FakeVideoRenderer renderer;
   EXPECT_TRUE(channel_->SetSink(last_ssrc_, &renderer));
 
-  webrtc::VideoFrame video_frame;
-  CreateBlackFrame(&video_frame, 4, 4);
-  video_frame.set_timestamp(kInitialTimestamp);
+  webrtc::VideoFrame video_frame(CreateBlackFrameBuffer(4, 4),
+                                 kInitialTimestamp, 0,
+                                 webrtc::kVideoRotation_0);
   // Initial NTP time is not available on the first frame, but should still be
   // able to be estimated.
   stream->InjectFrame(video_frame);
diff --git a/webrtc/media/engine/webrtcvideoframe.cc b/webrtc/media/engine/webrtcvideoframe.cc
index dfe012b..2a9bbcc 100644
--- a/webrtc/media/engine/webrtcvideoframe.cc
+++ b/webrtc/media/engine/webrtcvideoframe.cc
@@ -121,7 +121,9 @@
     new_height = dw;
   }
 
-  InitToEmptyBuffer(new_width, new_height);
+  rtc::scoped_refptr<webrtc::I420Buffer> buffer =
+      webrtc::I420Buffer::Create(new_width, new_height);
+  video_frame_buffer_ = buffer;
   rotation_ = apply_rotation ? webrtc::kVideoRotation_0 : rotation;
 
   int horiz_crop = ((w - dw) / 2) & ~1;
@@ -132,15 +134,10 @@
   int idh = (h < 0) ? -dh : dh;
   int r = libyuv::ConvertToI420(
       sample, sample_size,
-      video_frame_buffer_->MutableDataY(),
-      video_frame_buffer_->StrideY(),
-      video_frame_buffer_->MutableDataU(),
-      video_frame_buffer_->StrideU(),
-      video_frame_buffer_->MutableDataV(),
-      video_frame_buffer_->StrideV(),
-      horiz_crop, vert_crop,
-      w, h,
-      dw, idh,
+      buffer->MutableDataY(), buffer->StrideY(),
+      buffer->MutableDataU(), buffer->StrideU(),
+      buffer->MutableDataV(), buffer->StrideV(),
+      horiz_crop, vert_crop, w, h, dw, idh,
       static_cast<libyuv::RotationMode>(
           apply_rotation ? rotation : webrtc::kVideoRotation_0),
       format);
@@ -154,7 +151,7 @@
 }
 
 void WebRtcVideoFrame::InitToEmptyBuffer(int w, int h) {
-  video_frame_buffer_ = new rtc::RefCountedObject<webrtc::I420Buffer>(w, h);
+  video_frame_buffer_ = webrtc::I420Buffer::Create(w, h);
   rotation_ = webrtc::kVideoRotation_0;
 }
 
diff --git a/webrtc/modules/video_capture/test/video_capture_unittest.cc b/webrtc/modules/video_capture/test/video_capture_unittest.cc
index 839ab80..10f3a2b 100644
--- a/webrtc/modules/video_capture/test/video_capture_unittest.cc
+++ b/webrtc/modules/video_capture/test/video_capture_unittest.cc
@@ -420,15 +420,19 @@
     capability.maxFPS = kTestFramerate;
     capture_callback_.SetExpectedCapability(capability);
 
-    test_frame_.CreateEmptyFrame(kTestWidth, kTestHeight, kTestWidth,
-                                 ((kTestWidth + 1) / 2), (kTestWidth + 1) / 2);
-    SleepMs(1); // Wait 1ms so that two tests can't have the same timestamp.
-    memset(test_frame_.video_frame_buffer()->MutableDataY(), 127,
-           kTestWidth * kTestHeight);
-    memset(test_frame_.video_frame_buffer()->MutableDataU(), 127,
+    rtc::scoped_refptr<webrtc::I420Buffer> buffer = webrtc::I420Buffer::Create(
+        kTestWidth, kTestHeight,
+        kTestWidth, ((kTestWidth + 1) / 2), (kTestWidth + 1) / 2);
+
+    memset(buffer->MutableDataY(), 127, kTestWidth * kTestHeight);
+    memset(buffer->MutableDataU(), 127,
            ((kTestWidth + 1) / 2) * ((kTestHeight + 1) / 2));
-    memset(test_frame_.video_frame_buffer()->MutableDataV(), 127,
+    memset(buffer->MutableDataV(), 127,
            ((kTestWidth + 1) / 2) * ((kTestHeight + 1) / 2));
+    test_frame_.reset(
+        new webrtc::VideoFrame(buffer, 0, 0, webrtc::kVideoRotation_0));
+
+    SleepMs(1);  // Wait 1ms so that two tests can't have the same timestamp.
 
     capture_module_->RegisterCaptureDataCallback(capture_callback_);
     capture_module_->RegisterCaptureCallback(capture_feedback_);
@@ -443,7 +447,7 @@
   webrtc::VideoCaptureExternal* capture_input_interface_;
   rtc::scoped_refptr<VideoCaptureModule> capture_module_;
   std::unique_ptr<webrtc::ProcessThread> process_module_;
-  webrtc::VideoFrame test_frame_;
+  std::unique_ptr<webrtc::VideoFrame> test_frame_;
   TestVideoCaptureCallback capture_callback_;
   TestVideoCaptureFeedBack capture_feedback_;
 };
@@ -451,13 +455,13 @@
 // Test input of external video frames.
 TEST_F(VideoCaptureExternalTest, TestExternalCapture) {
   size_t length = webrtc::CalcBufferSize(webrtc::kI420,
-                                         test_frame_.width(),
-                                         test_frame_.height());
+                                         test_frame_->width(),
+                                         test_frame_->height());
   std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
-  webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
+  webrtc::ExtractBuffer(*test_frame_, length, test_buffer.get());
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
       length, capture_callback_.capability(), 0));
-  EXPECT_TRUE(capture_callback_.CompareLastFrame(test_frame_));
+  EXPECT_TRUE(capture_callback_.CompareLastFrame(*test_frame_));
 }
 
 // Test frame rate and no picture alarm.
@@ -472,13 +476,14 @@
   uint64_t startTime = rtc::TimeNanos();
 
   while ((rtc::TimeNanos() - startTime) < testTime) {
-     size_t length = webrtc::CalcBufferSize(webrtc::kI420,
-                                            test_frame_.width(),
-                                            test_frame_.height());
-     std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
-     webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
-     EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
-       length, capture_callback_.capability(), 0));
+    size_t length = webrtc::CalcBufferSize(webrtc::kI420,
+                                           test_frame_->width(),
+                                           test_frame_->height());
+    std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
+    webrtc::ExtractBuffer(*test_frame_, length, test_buffer.get());
+    EXPECT_EQ(
+        0, capture_input_interface_->IncomingFrame(
+               test_buffer.get(), length, capture_callback_.capability(), 0));
     SleepMs(100);
   }
   EXPECT_TRUE(capture_feedback_.frame_rate() >= 8 &&
@@ -489,10 +494,10 @@
   startTime = rtc::TimeNanos();
   while ((rtc::TimeNanos() - startTime) < testTime) {
     size_t length = webrtc::CalcBufferSize(webrtc::kI420,
-                                           test_frame_.width(),
-                                           test_frame_.height());
+                                           test_frame_->width(),
+                                           test_frame_->height());
     std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
-    webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
+    webrtc::ExtractBuffer(*test_frame_, length, test_buffer.get());
     EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
       length, capture_callback_.capability(), 0));
     SleepMs(1000 / 30);
@@ -507,10 +512,10 @@
 TEST_F(VideoCaptureExternalTest, Rotation) {
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_0));
   size_t length = webrtc::CalcBufferSize(webrtc::kI420,
-                                         test_frame_.width(),
-                                         test_frame_.height());
+                                         test_frame_->width(),
+                                         test_frame_->height());
   std::unique_ptr<uint8_t[]> test_buffer(new uint8_t[length]);
-  webrtc::ExtractBuffer(test_frame_, length, test_buffer.get());
+  webrtc::ExtractBuffer(*test_frame_, length, test_buffer.get());
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_90));
diff --git a/webrtc/modules/video_capture/video_capture_impl.cc b/webrtc/modules/video_capture/video_capture_impl.cc
index e6b2d55..90ac267 100644
--- a/webrtc/modules/video_capture/video_capture_impl.cc
+++ b/webrtc/modules/video_capture/video_capture_impl.cc
@@ -275,14 +275,14 @@
         // Setting absolute height (in case it was negative).
         // In Windows, the image starts bottom left, instead of top left.
         // Setting a negative source height, inverts the image (within LibYuv).
-        _captureFrame.CreateEmptyFrame(target_width,
-                                       abs(target_height),
-                                       stride_y,
-                                       stride_uv, stride_uv);
+
+        // TODO(nisse): Use a pool?
+        rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(
+            target_width, abs(target_height), stride_y, stride_uv, stride_uv);
         const int conversionResult = ConvertToI420(
             commonVideoType, videoFrame, 0, 0,  // No cropping
             width, height, videoFrameLength,
-            apply_rotation ? _rotateFrame : kVideoRotation_0, &_captureFrame);
+            apply_rotation ? _rotateFrame : kVideoRotation_0, buffer.get());
         if (conversionResult < 0)
         {
           LOG(LS_ERROR) << "Failed to convert capture frame from type "
@@ -290,15 +290,12 @@
             return -1;
         }
 
-        if (!apply_rotation) {
-          _captureFrame.set_rotation(_rotateFrame);
-        } else {
-          _captureFrame.set_rotation(kVideoRotation_0);
-        }
-        _captureFrame.set_ntp_time_ms(captureTime);
-        _captureFrame.set_render_time_ms(rtc::TimeMillis());
+        VideoFrame captureFrame(
+            buffer, 0, rtc::TimeMillis(),
+            !apply_rotation ? _rotateFrame : kVideoRotation_0);
+        captureFrame.set_ntp_time_ms(captureTime);
 
-        DeliverCapturedFrame(_captureFrame);
+        DeliverCapturedFrame(captureFrame);
     }
     else // Encoded format
     {
diff --git a/webrtc/modules/video_capture/video_capture_impl.h b/webrtc/modules/video_capture/video_capture_impl.h
index 7d785c3..e9fee7e 100644
--- a/webrtc/modules/video_capture/video_capture_impl.h
+++ b/webrtc/modules/video_capture/video_capture_impl.h
@@ -137,8 +137,6 @@
     VideoRotation _rotateFrame;  // Set if the frame should be rotated by the
                                  // capture module.
 
-    VideoFrame _captureFrame;
-
     // Indicate whether rotation should be applied before delivered externally.
     bool apply_rotation_;
 };
diff --git a/webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc b/webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc
index bbf1ee1..3cc08d2 100644
--- a/webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc
+++ b/webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc
@@ -121,52 +121,47 @@
     return ret;
   }
 
-  // The video frame is stored in |video_frame|. |av_frame| is FFmpeg's version
-  // of a video frame and will be set up to reference |video_frame|'s buffers.
-
-  // TODO(nisse): The VideoFrame's timestamp and rotation info is not used.
-  // Refactor to do not use a VideoFrame object at all.
+  // The video frame is stored in |frame_buffer|. |av_frame| is FFmpeg's version
+  // of a video frame and will be set up to reference |frame_buffer|'s data.
 
   // FFmpeg expects the initial allocation to be zero-initialized according to
   // http://crbug.com/390941. Our pool is set up to zero-initialize new buffers.
-  VideoFrame* video_frame = new VideoFrame(
-      decoder->pool_.CreateBuffer(width, height),
-      0 /* timestamp */, 0 /* render_time_ms */, kVideoRotation_0);
+  // TODO(nisse): Delete that feature from the video pool, instead add
+  // an explicit call to InitializeData here.
+  rtc::scoped_refptr<I420Buffer> frame_buffer =
+      decoder->pool_.CreateBuffer(width, height);
 
+  int y_size = width * height;
+  int uv_size = ((width + 1) / 2) * ((height + 1) / 2);
   // DCHECK that we have a continuous buffer as is required.
-  RTC_DCHECK_EQ(video_frame->video_frame_buffer()->DataU(),
-                video_frame->video_frame_buffer()->DataY() +
-                video_frame->allocated_size(kYPlane));
-  RTC_DCHECK_EQ(video_frame->video_frame_buffer()->DataV(),
-                video_frame->video_frame_buffer()->DataU() +
-                video_frame->allocated_size(kUPlane));
-  int total_size = video_frame->allocated_size(kYPlane) +
-                   video_frame->allocated_size(kUPlane) +
-                   video_frame->allocated_size(kVPlane);
+  RTC_DCHECK_EQ(frame_buffer->DataU(), frame_buffer->DataY() + y_size);
+  RTC_DCHECK_EQ(frame_buffer->DataV(), frame_buffer->DataU() + uv_size);
+  int total_size = y_size + 2 * uv_size;
 
   av_frame->format = context->pix_fmt;
   av_frame->reordered_opaque = context->reordered_opaque;
 
   // Set |av_frame| members as required by FFmpeg.
-  av_frame->data[kYPlaneIndex] =
-      video_frame->video_frame_buffer()->MutableDataY();
-  av_frame->linesize[kYPlaneIndex] =
-      video_frame->video_frame_buffer()->StrideY();
-  av_frame->data[kUPlaneIndex] =
-      video_frame->video_frame_buffer()->MutableDataU();
-  av_frame->linesize[kUPlaneIndex] =
-      video_frame->video_frame_buffer()->StrideU();
-  av_frame->data[kVPlaneIndex] =
-      video_frame->video_frame_buffer()->MutableDataV();
-  av_frame->linesize[kVPlaneIndex] =
-      video_frame->video_frame_buffer()->StrideV();
+  av_frame->data[kYPlaneIndex] = frame_buffer->MutableDataY();
+  av_frame->linesize[kYPlaneIndex] = frame_buffer->StrideY();
+  av_frame->data[kUPlaneIndex] = frame_buffer->MutableDataU();
+  av_frame->linesize[kUPlaneIndex] = frame_buffer->StrideU();
+  av_frame->data[kVPlaneIndex] = frame_buffer->MutableDataV();
+  av_frame->linesize[kVPlaneIndex] = frame_buffer->StrideV();
   RTC_DCHECK_EQ(av_frame->extended_data, av_frame->data);
 
-  av_frame->buf[0] = av_buffer_create(av_frame->data[kYPlaneIndex],
-                                      total_size,
-                                      AVFreeBuffer2,
-                                      static_cast<void*>(video_frame),
-                                      0);
+  // Create a VideoFrame object, to keep a reference to the buffer.
+  // TODO(nisse): The VideoFrame's timestamp and rotation info is not used.
+  // Refactor to do not use a VideoFrame object at all.
+  av_frame->buf[0] = av_buffer_create(
+      av_frame->data[kYPlaneIndex],
+      total_size,
+      AVFreeBuffer2,
+      static_cast<void*>(new VideoFrame(frame_buffer,
+                                        0 /* timestamp */,
+                                        0 /* render_time_ms */,
+                                        kVideoRotation_0)),
+      0);
   RTC_CHECK(av_frame->buf[0]);
   return 0;
 }
diff --git a/webrtc/modules/video_coding/codecs/i420/i420.cc b/webrtc/modules/video_coding/codecs/i420/i420.cc
index 93204dd..d0c8d0c 100644
--- a/webrtc/modules/video_coding/codecs/i420/i420.cc
+++ b/webrtc/modules/video_coding/codecs/i420/i420.cc
@@ -137,8 +137,7 @@
 }
 
 I420Decoder::I420Decoder()
-    : _decodedImage(),
-      _width(0),
+    : _width(0),
       _height(0),
       _inited(false),
       _decodeCompleteCallback(NULL) {}
@@ -199,17 +198,19 @@
   }
   // Set decoded image parameters.
   int half_width = (_width + 1) / 2;
-  _decodedImage.CreateEmptyFrame(_width, _height, _width, half_width,
-                                 half_width);
-  // Converting from buffer to plane representation.
+  rtc::scoped_refptr<webrtc::I420Buffer> frame_buffer =
+      I420Buffer::Create(_width, _height, _width, half_width, half_width);
+
+  // Converting from raw buffer I420Buffer.
   int ret = ConvertToI420(kI420, buffer, 0, 0, _width, _height, 0,
-                          kVideoRotation_0, &_decodedImage);
+                          kVideoRotation_0, frame_buffer.get());
   if (ret < 0) {
     return WEBRTC_VIDEO_CODEC_MEMORY;
   }
-  _decodedImage.set_timestamp(inputImage._timeStamp);
 
-  _decodeCompleteCallback->Decoded(_decodedImage);
+  VideoFrame decoded_image(frame_buffer, inputImage._timeStamp, 0,
+                           webrtc::kVideoRotation_0);
+  _decodeCompleteCallback->Decoded(decoded_image);
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc
index 766e517..1c8037a 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.cc
@@ -298,11 +298,10 @@
         return ret;
       }
     } else {
-      VideoFrame dst_frame;
-      // Making sure that destination frame is of sufficient size.
       // Aligning stride values based on width.
-      dst_frame.CreateEmptyFrame(dst_width, dst_height, dst_width,
-                                 (dst_width + 1) / 2, (dst_width + 1) / 2);
+      rtc::scoped_refptr<I420Buffer> dst_buffer =
+          I420Buffer::Create(dst_width, dst_height, dst_width,
+                             (dst_width + 1) / 2, (dst_width + 1) / 2);
       libyuv::I420Scale(input_image.video_frame_buffer()->DataY(),
                         input_image.video_frame_buffer()->StrideY(),
                         input_image.video_frame_buffer()->DataU(),
@@ -310,18 +309,16 @@
                         input_image.video_frame_buffer()->DataV(),
                         input_image.video_frame_buffer()->StrideV(),
                         src_width, src_height,
-                        dst_frame.video_frame_buffer()->MutableDataY(),
-                        dst_frame.video_frame_buffer()->StrideY(),
-                        dst_frame.video_frame_buffer()->MutableDataU(),
-                        dst_frame.video_frame_buffer()->StrideU(),
-                        dst_frame.video_frame_buffer()->MutableDataV(),
-                        dst_frame.video_frame_buffer()->StrideV(),
+                        dst_buffer->MutableDataY(), dst_buffer->StrideY(),
+                        dst_buffer->MutableDataU(), dst_buffer->StrideU(),
+                        dst_buffer->MutableDataV(), dst_buffer->StrideV(),
                         dst_width, dst_height,
                         libyuv::kFilterBilinear);
-      dst_frame.set_timestamp(input_image.timestamp());
-      dst_frame.set_render_time_ms(input_image.render_time_ms());
+
       int ret = streaminfos_[stream_idx].encoder->Encode(
-          dst_frame, codec_specific_info, &stream_frame_types);
+          VideoFrame(dst_buffer, input_image.timestamp(),
+                     input_image.render_time_ms(), webrtc::kVideoRotation_0),
+          codec_specific_info, &stream_frame_types);
       if (ret != WEBRTC_VIDEO_CODEC_OK) {
         return ret;
       }
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
index 47d2322d..d13dbb16 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter_unittest.cc
@@ -535,17 +535,11 @@
       .WillOnce(Return(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE));
 
   // Send a fake frame and assert the return is software fallback.
-  VideoFrame input_frame;
   int half_width = (kDefaultWidth + 1) / 2;
-  input_frame.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, kDefaultWidth,
-                                half_width, half_width);
-  memset(input_frame.video_frame_buffer()->MutableDataY(), 0,
-         input_frame.allocated_size(kYPlane));
-  memset(input_frame.video_frame_buffer()->MutableDataU(), 0,
-         input_frame.allocated_size(kUPlane));
-  memset(input_frame.video_frame_buffer()->MutableDataV(), 0,
-         input_frame.allocated_size(kVPlane));
-
+  rtc::scoped_refptr<I420Buffer> input_buffer = I420Buffer::Create(
+      kDefaultWidth, kDefaultHeight, kDefaultWidth, half_width, half_width);
+  input_buffer->InitializeData();
+  VideoFrame input_frame(input_buffer, 0, 0, webrtc::kVideoRotation_0);
   std::vector<FrameType> frame_types(3, kVideoFrameKey);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE,
             adapter_->Encode(input_frame, nullptr, &frame_types));
diff --git a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
index e2bd71e..22e8645 100644
--- a/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
+++ b/webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h
@@ -236,8 +236,8 @@
     }
   }
 
-  // Fills in an VideoFrameBuffer from |plane_colors|.
-  static void CreateImage(const rtc::scoped_refptr<VideoFrameBuffer>& buffer,
+  // Fills in an I420Buffer from |plane_colors|.
+  static void CreateImage(const rtc::scoped_refptr<I420Buffer>& buffer,
                           int plane_colors[kNumOfPlanes]) {
     int width = buffer->width();
     int height = buffer->height();
@@ -317,14 +317,11 @@
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     EXPECT_EQ(0, decoder_->InitDecode(&settings_, 1));
     int half_width = (kDefaultWidth + 1) / 2;
-    input_frame_.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, kDefaultWidth,
-                                  half_width, half_width);
-    memset(input_frame_.video_frame_buffer()->MutableDataY(), 0,
-           input_frame_.allocated_size(kYPlane));
-    memset(input_frame_.video_frame_buffer()->MutableDataU(), 0,
-           input_frame_.allocated_size(kUPlane));
-    memset(input_frame_.video_frame_buffer()->MutableDataV(), 0,
-           input_frame_.allocated_size(kVPlane));
+    input_buffer_ = I420Buffer::Create(kDefaultWidth, kDefaultHeight,
+                                       kDefaultWidth, half_width, half_width);
+    input_buffer_->InitializeData();
+    input_frame_.reset(
+        new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
   }
 
   virtual void TearDown() {
@@ -396,33 +393,33 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, kNumberOfSimulcastStreams);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, kNumberOfSimulcastStreams);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     frame_types[0] = kVideoFrameKey;
     ExpectStreams(kVideoFrameKey, kNumberOfSimulcastStreams);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     std::fill(frame_types.begin(), frame_types.end(), kVideoFrameDelta);
     frame_types[1] = kVideoFrameKey;
     ExpectStreams(kVideoFrameKey, kNumberOfSimulcastStreams);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     std::fill(frame_types.begin(), frame_types.end(), kVideoFrameDelta);
     frame_types[2] = kVideoFrameKey;
     ExpectStreams(kVideoFrameKey, kNumberOfSimulcastStreams);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     std::fill(frame_types.begin(), frame_types.end(), kVideoFrameDelta);
     ExpectStreams(kVideoFrameDelta, kNumberOfSimulcastStreams);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingAllStreams() {
@@ -431,11 +428,11 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 1);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 1);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingTwoStreams() {
@@ -444,11 +441,11 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 1);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 1);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingTwoStreamsOneMaxedOut() {
@@ -458,11 +455,11 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 1);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 1);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingOneStream() {
@@ -471,11 +468,11 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 2);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 2);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestPaddingOneStreamTwoMaxedOut() {
@@ -486,11 +483,11 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 2);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 2);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestSendAllStreams() {
@@ -500,11 +497,11 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 3);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 3);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestDisablingStreams() {
@@ -513,47 +510,47 @@
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     ExpectStreams(kVideoFrameKey, 3);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     ExpectStreams(kVideoFrameDelta, 3);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should only get two streams and padding for one.
     encoder_->SetRates(
         kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] / 2, 30);
     ExpectStreams(kVideoFrameDelta, 2);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should only get the first stream and padding for two.
     encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1] / 2, 30);
     ExpectStreams(kVideoFrameDelta, 1);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We don't have enough bitrate for the thumbnail stream, but we should get
     // it anyway with current configuration.
     encoder_->SetRates(kTargetBitrates[0] - 1, 30);
     ExpectStreams(kVideoFrameDelta, 1);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should only get two streams and padding for one.
     encoder_->SetRates(
         kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] / 2, 30);
     // We get a key frame because a new stream is being enabled.
     ExpectStreams(kVideoFrameKey, 2);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // We should get all three streams.
     encoder_->SetRates(
         kTargetBitrates[0] + kTargetBitrates[1] + kTargetBitrates[2], 30);
     // We get a key frame because a new stream is being enabled.
     ExpectStreams(kVideoFrameKey, 3);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void SwitchingToOneStream(int width, int height) {
@@ -571,14 +568,12 @@
     }
     // Setting input image to new resolution.
     int half_width = (settings_.width + 1) / 2;
-    input_frame_.CreateEmptyFrame(settings_.width, settings_.height,
-                                  settings_.width, half_width, half_width);
-    memset(input_frame_.video_frame_buffer()->MutableDataY(), 0,
-           input_frame_.allocated_size(kYPlane));
-    memset(input_frame_.video_frame_buffer()->MutableDataU(), 0,
-           input_frame_.allocated_size(kUPlane));
-    memset(input_frame_.video_frame_buffer()->MutableDataV(), 0,
-           input_frame_.allocated_size(kVPlane));
+    input_buffer_ = I420Buffer::Create(settings_.width, settings_.height,
+                                       settings_.width, half_width, half_width);
+    input_buffer_->InitializeData();
+
+    input_frame_.reset(
+        new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
 
     // The for loop above did not set the bitrate of the highest layer.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1]
@@ -603,7 +598,7 @@
         .Times(1)
         .WillRepeatedly(Return(
             EncodedImageCallback::Result(EncodedImageCallback::Result::OK, 0)));
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
 
     // Switch back.
     DefaultSettings(&settings_, kDefaultTemporalLayerProfile);
@@ -614,15 +609,12 @@
     ExpectStreams(kVideoFrameKey, 1);
     // Resize |input_frame_| to the new resolution.
     half_width = (settings_.width + 1) / 2;
-    input_frame_.CreateEmptyFrame(settings_.width, settings_.height,
-                                  settings_.width, half_width, half_width);
-    memset(input_frame_.video_frame_buffer()->MutableDataY(), 0,
-           input_frame_.allocated_size(kYPlane));
-    memset(input_frame_.video_frame_buffer()->MutableDataU(), 0,
-           input_frame_.allocated_size(kUPlane));
-    memset(input_frame_.video_frame_buffer()->MutableDataV(), 0,
-           input_frame_.allocated_size(kVPlane));
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, &frame_types));
+    input_buffer_ = I420Buffer::Create(settings_.width, settings_.height,
+                                       settings_.width, half_width, half_width);
+    input_buffer_->InitializeData();
+    input_frame_.reset(
+        new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, &frame_types));
   }
 
   void TestSwitchingToOneStream() { SwitchingToOneStream(1024, 768); }
@@ -637,7 +629,7 @@
 
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     int picture_id = -1;
     int temporal_layer = -1;
     bool layer_sync = false;
@@ -647,22 +639,22 @@
     EXPECT_TRUE(layer_sync);
     int key_frame_picture_id = picture_id;
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(2, temporal_layer);
     EXPECT_TRUE(layer_sync);
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(1, temporal_layer);
     EXPECT_TRUE(layer_sync);
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(2, temporal_layer);
@@ -675,8 +667,8 @@
     // Must match last key frame to trigger.
     codec_specific.codecSpecific.VP8.pictureIdRPSI = key_frame_picture_id;
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, &codec_specific, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, &codec_specific, NULL));
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
 
@@ -686,8 +678,8 @@
     // Must match last key frame to trigger, test bad id.
     codec_specific.codecSpecific.VP8.pictureIdRPSI = key_frame_picture_id + 17;
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, &codec_specific, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, &codec_specific, NULL));
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
 
@@ -711,9 +703,9 @@
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
+    CreateImage(input_buffer_, plane_offset);
 
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     int picture_id = -1;
     int temporal_layer = -1;
     bool layer_sync = false;
@@ -727,27 +719,27 @@
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    CreateImage(input_buffer_, plane_offset);
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
+    CreateImage(input_buffer_, plane_offset);
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
+    CreateImage(input_buffer_, plane_offset);
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
 
     CodecSpecificInfo codec_specific;
     codec_specific.codecType = kVideoCodecVP8;
@@ -759,10 +751,10 @@
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
+    CreateImage(input_buffer_, plane_offset);
 
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, &codec_specific, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, &codec_specific, NULL));
 
     EncodedImage encoded_frame;
     encoder_callback.GetLastEncodedKeyFrame(&encoded_frame);
@@ -784,47 +776,47 @@
     bool expected_layer_sync[3] = {false, false, false};
 
     // First frame: #0.
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(0, 0, 0, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, true, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #1.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(2, 2, 2, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, true, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #2.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(1, 1, 1, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, true, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #3.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(2, 2, 2, expected_temporal_idx);
     SetExpectedValues3<bool>(false, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #4.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(0, 0, 0, expected_temporal_idx);
     SetExpectedValues3<bool>(false, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #5.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(2, 2, 2, expected_temporal_idx);
     SetExpectedValues3<bool>(false, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
@@ -853,47 +845,47 @@
     bool expected_layer_sync[3] = {false, false, false};
 
     // First frame: #0.
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(0, 0, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #1.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(2, 1, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(true, true, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #2.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(1, 0, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(true, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #3.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(2, 1, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(false, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #4.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(0, 0, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(false, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
 
     // Next frame: #5.
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
     SetExpectedValues3<int>(2, 1, 255, expected_temporal_idx);
     SetExpectedValues3<bool>(false, false, false, expected_layer_sync);
     VerifyTemporalIdxAndSyncForAllSpatialLayers(
@@ -911,24 +903,27 @@
     // 1. stride > width 2. stride_y != stride_uv/2
     int stride_y = kDefaultWidth + 20;
     int stride_uv = ((kDefaultWidth + 1) / 2) + 5;
-    input_frame_.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, stride_y,
-                                  stride_uv, stride_uv);
+    input_buffer_ = I420Buffer::Create(kDefaultWidth, kDefaultHeight, stride_y,
+                                       stride_uv, stride_uv);
+    input_frame_.reset(
+        new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
+
     // Set color.
     int plane_offset[kNumOfPlanes];
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
+    CreateImage(input_buffer_, plane_offset);
 
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(input_frame_.video_frame_buffer(), plane_offset);
-    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
+    CreateImage(input_buffer_, plane_offset);
+    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
 
     EncodedImage encoded_frame;
     // Only encoding one frame - so will be a key frame.
@@ -968,7 +963,8 @@
   std::unique_ptr<VP8Decoder> decoder_;
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
-  VideoFrame input_frame_;
+  rtc::scoped_refptr<I420Buffer> input_buffer_;
+  std::unique_ptr<VideoFrame> input_frame_;
 };
 
 }  // namespace testing
diff --git a/webrtc/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc b/webrtc/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
index 12dcb7c..4f3d99b 100644
--- a/webrtc/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/test/vp8_impl_unittest.cc
@@ -147,13 +147,15 @@
     EXPECT_EQ(stride_y, 176);
     EXPECT_EQ(stride_uv, 96);
 
-    input_frame_.CreateEmptyFrame(codec_inst_.width, codec_inst_.height,
-                                  stride_y, stride_uv, stride_uv);
-    input_frame_.set_timestamp(kTestTimestamp);
+    rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(
+        codec_inst_.width, codec_inst_.height, stride_y, stride_uv, stride_uv);
     // Using ConvertToI420 to add stride to the image.
-    EXPECT_EQ(0, ConvertToI420(kI420, source_buffer_.get(), 0, 0,
-                               codec_inst_.width, codec_inst_.height, 0,
-                               kVideoRotation_0, &input_frame_));
+    EXPECT_EQ(
+        0, ConvertToI420(kI420, source_buffer_.get(), 0, 0, codec_inst_.width,
+                         codec_inst_.height, 0, kVideoRotation_0,
+                         buffer.get()));
+    input_frame_.reset(
+        new VideoFrame(buffer, kTestTimestamp, 0, webrtc::kVideoRotation_0));
   }
 
   void SetUpEncodeDecode() {
@@ -195,7 +197,7 @@
   std::unique_ptr<Vp8UnitTestDecodeCompleteCallback> decode_complete_callback_;
   std::unique_ptr<uint8_t[]> source_buffer_;
   FILE* source_file_;
-  VideoFrame input_frame_;
+  std::unique_ptr<VideoFrame> input_frame_;
   std::unique_ptr<VideoEncoder> encoder_;
   std::unique_ptr<VideoDecoder> decoder_;
   EncodedImage encoded_frame_;
@@ -237,7 +239,7 @@
 #endif
 TEST_F(TestVp8Impl, MAYBE_AlignedStrideEncodeDecode) {
   SetUpEncodeDecode();
-  encoder_->Encode(input_frame_, NULL, NULL);
+  encoder_->Encode(*input_frame_, NULL, NULL);
   EXPECT_GT(WaitForEncodedFrame(), 0u);
   // First frame should be a key frame.
   encoded_frame_._frameType = kVideoFrameKey;
@@ -246,7 +248,7 @@
             decoder_->Decode(encoded_frame_, false, NULL));
   EXPECT_GT(WaitForDecodedFrame(), 0u);
   // Compute PSNR on all planes (faster than SSIM).
-  EXPECT_GT(I420PSNR(&input_frame_, &decoded_frame_), 36);
+  EXPECT_GT(I420PSNR(input_frame_.get(), &decoded_frame_), 36);
   EXPECT_EQ(kTestTimestamp, decoded_frame_.timestamp());
   EXPECT_EQ(kTestNtpTimeMs, decoded_frame_.ntp_time_ms());
 }
@@ -258,7 +260,7 @@
 #endif
 TEST_F(TestVp8Impl, MAYBE_DecodeWithACompleteKeyFrame) {
   SetUpEncodeDecode();
-  encoder_->Encode(input_frame_, NULL, NULL);
+  encoder_->Encode(*input_frame_, NULL, NULL);
   EXPECT_GT(WaitForEncodedFrame(), 0u);
   // Setting complete to false -> should return an error.
   encoded_frame_._completeFrame = false;
@@ -273,7 +275,7 @@
   encoded_frame_._frameType = kVideoFrameKey;
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             decoder_->Decode(encoded_frame_, false, NULL));
-  EXPECT_GT(I420PSNR(&input_frame_, &decoded_frame_), 36);
+  EXPECT_GT(I420PSNR(input_frame_.get(), &decoded_frame_), 36);
 }
 
 }  // namespace webrtc
diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
index ef5e8e3..73a7eb6 100644
--- a/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/vp8_impl.cc
@@ -1306,18 +1306,18 @@
   last_frame_width_ = img->d_w;
   last_frame_height_ = img->d_h;
   // Allocate memory for decoded image.
-  VideoFrame decoded_image(buffer_pool_.CreateBuffer(img->d_w, img->d_h),
-                           timestamp, 0, kVideoRotation_0);
+  rtc::scoped_refptr<I420Buffer> buffer =
+      buffer_pool_.CreateBuffer(img->d_w, img->d_h);
+
   libyuv::I420Copy(img->planes[VPX_PLANE_Y], img->stride[VPX_PLANE_Y],
                    img->planes[VPX_PLANE_U], img->stride[VPX_PLANE_U],
                    img->planes[VPX_PLANE_V], img->stride[VPX_PLANE_V],
-                   decoded_image.video_frame_buffer()->MutableDataY(),
-                   decoded_image.video_frame_buffer()->StrideY(),
-                   decoded_image.video_frame_buffer()->MutableDataU(),
-                   decoded_image.video_frame_buffer()->StrideU(),
-                   decoded_image.video_frame_buffer()->MutableDataV(),
-                   decoded_image.video_frame_buffer()->StrideV(),
+                   buffer->MutableDataY(), buffer->StrideY(),
+                   buffer->MutableDataU(), buffer->StrideU(),
+                   buffer->MutableDataV(), buffer->StrideV(),
                    img->d_w, img->d_h);
+
+  VideoFrame decoded_image(buffer, timestamp, 0, kVideoRotation_0);
   decoded_image.set_ntp_time_ms(ntp_time_ms);
   int ret = decode_complete_callback_->Decoded(decoded_image);
   if (ret != 0)
diff --git a/webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.cc b/webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.cc
index d7927eb..dcc0619 100644
--- a/webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.cc
+++ b/webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.cc
@@ -148,7 +148,7 @@
     return -1;
   }
   EXPECT_EQ(0, decoder->InitDecode(&inst, 1));
-  webrtc::VideoFrame input_frame;
+
   size_t length = webrtc::CalcBufferSize(webrtc::kI420, width, height);
   std::unique_ptr<uint8_t[]> frame_buffer(new uint8_t[length]);
 
@@ -163,14 +163,18 @@
   int64_t starttime = rtc::TimeMillis();
   int frame_cnt = 1;
   int frames_processed = 0;
-  input_frame.CreateEmptyFrame(width, height, width, half_width, half_width);
+  rtc::scoped_refptr<webrtc::I420Buffer> i420_buffer =
+      webrtc::I420Buffer::Create(width, height, width, half_width, half_width);
+
   while (!feof(input_file) &&
          (num_frames == -1 || frames_processed < num_frames)) {
     if (fread(frame_buffer.get(), 1, length, input_file) != length)
       continue;
     if (frame_cnt >= start_frame) {
       webrtc::ConvertToI420(webrtc::kI420, frame_buffer.get(), 0, 0, width,
-                            height, 0, webrtc::kVideoRotation_0, &input_frame);
+                            height, 0, webrtc::kVideoRotation_0, &i420_buffer);
+      webrtc::VideoFrame input_frame(i420_buffer, 0, 0,
+                                     webrtc::kVideoRotation_0);
       encoder->Encode(input_frame, NULL, NULL);
       decoder->Decode(encoder_callback.encoded_image(), false, NULL);
       ++frames_processed;
diff --git a/webrtc/modules/video_processing/test/denoiser_test.cc b/webrtc/modules/video_processing/test/denoiser_test.cc
index 7507e92..a968859 100644
--- a/webrtc/modules/video_processing/test/denoiser_test.cc
+++ b/webrtc/modules/video_processing/test/denoiser_test.cc
@@ -141,8 +141,10 @@
   while (fread(video_buffer.get(), 1, frame_length_, source_file_) ==
          frame_length_) {
     // Using ConvertToI420 to add stride to the image.
+    rtc::scoped_refptr<webrtc::I420Buffer> input_buffer =
+        I420Buffer::Create(width_, height_, width_, half_width_, half_width_);
     EXPECT_EQ(0, ConvertToI420(kI420, video_buffer.get(), 0, 0, width_, height_,
-                               0, kVideoRotation_0, &video_frame_));
+                               0, kVideoRotation_0, input_buffer.get()));
 
     rtc::scoped_refptr<I420Buffer>* p_denoised_c = &denoised_frame_c;
     rtc::scoped_refptr<I420Buffer>* p_denoised_prev_c = &denoised_frame_prev_c;
@@ -157,11 +159,9 @@
       p_denoised_sse_neon = &denoised_frame_prev_sse_neon;
       p_denoised_prev_sse_neon = &denoised_frame_sse_neon;
     }
-    denoiser_c.DenoiseFrame(video_frame_.video_frame_buffer(),
-                            p_denoised_c, p_denoised_prev_c,
+    denoiser_c.DenoiseFrame(input_buffer, p_denoised_c, p_denoised_prev_c,
                             false);
-    denoiser_sse_neon.DenoiseFrame(video_frame_.video_frame_buffer(),
-                                   p_denoised_sse_neon,
+    denoiser_sse_neon.DenoiseFrame(input_buffer, p_denoised_sse_neon,
                                    p_denoised_prev_sse_neon, false);
     // Invert the flag.
     denoised_frame_toggle ^= 1;
diff --git a/webrtc/modules/video_processing/test/video_processing_unittest.cc b/webrtc/modules/video_processing/test/video_processing_unittest.cc
index 9e61b51..8c1154a 100644
--- a/webrtc/modules/video_processing/test/video_processing_unittest.cc
+++ b/webrtc/modules/video_processing/test/video_processing_unittest.cc
@@ -15,6 +15,7 @@
 #include <memory>
 #include <string>
 
+#include "webrtc/base/keep_ref_until_done.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/test/testsupport/fileutils.h"
@@ -33,24 +34,25 @@
                                      int target_height,
                                      VideoProcessing* vpm,
                                      const VideoFrame* out_frame);
-static void CropFrame(const uint8_t* source_data,
-                      int source_width,
-                      int source_height,
-                      int offset_x,
-                      int offset_y,
-                      int cropped_width,
-                      int cropped_height,
-                      VideoFrame* cropped_frame);
+rtc::scoped_refptr<VideoFrameBuffer> CropBuffer(
+    const rtc::scoped_refptr<VideoFrameBuffer>& source_buffer,
+    int source_width,
+    int source_height,
+    int offset_x,
+    int offset_y,
+    int cropped_width,
+    int cropped_height);
 // The |source_data| is cropped and scaled to |target_width| x |target_height|,
 // and then scaled back to the expected cropped size. |expected_psnr| is used to
 // verify basic quality, and is set to be ~0.1/0.05dB lower than actual PSNR
 // verified under the same conditions.
-static void TestSize(const VideoFrame& source_frame,
-                     const VideoFrame& cropped_source_frame,
-                     int target_width,
-                     int target_height,
-                     double expected_psnr,
-                     VideoProcessing* vpm);
+static void TestSize(
+    const VideoFrame& source_frame,
+    const rtc::scoped_refptr<VideoFrameBuffer>& cropped_source_buffer,
+    int target_width,
+    int target_height,
+    double expected_psnr,
+    VideoProcessing* vpm);
 static void WriteProcessedFrameForVisualInspection(const VideoFrame& source,
                                                    const VideoFrame& processed);
 
@@ -68,15 +70,6 @@
   vp_ = VideoProcessing::Create();
   ASSERT_TRUE(vp_ != NULL);
 
-  video_frame_.CreateEmptyFrame(width_, height_, width_,
-                                half_width_, half_width_);
-  // Clear video frame so DrMemory/Valgrind will allow reads of the buffer.
-  memset(video_frame_.video_frame_buffer()->MutableDataY(), 0,
-         video_frame_.allocated_size(kYPlane));
-  memset(video_frame_.video_frame_buffer()->MutableDataU(), 0,
-         video_frame_.allocated_size(kUPlane));
-  memset(video_frame_.video_frame_buffer()->MutableDataV(), 0,
-         video_frame_.allocated_size(kVPlane));
   const std::string video_file =
       webrtc::test::ResourcePath("foreman_cif", "yuv");
   source_file_ = fopen(video_file.c_str(), "rb");
@@ -109,11 +102,18 @@
   VideoFrame* out_frame = NULL;
   // Set rescaling => output frame != NULL.
   vp_->SetInputFrameResampleMode(kFastRescaling);
-  PreprocessFrameAndVerify(video_frame_, resolution, resolution, vp_,
-                           out_frame);
+
+  rtc::scoped_refptr<webrtc::I420Buffer> buffer =
+      I420Buffer::Create(width_, height_, width_, half_width_, half_width_);
+
+  // Clear video frame so DrMemory/Valgrind will allow reads of the buffer.
+  buffer->InitializeData();
+  VideoFrame video_frame(buffer, 0, 0, webrtc::kVideoRotation_0);
+
+  PreprocessFrameAndVerify(video_frame, resolution, resolution, vp_, out_frame);
   // No rescaling=> output frame = NULL.
   vp_->SetInputFrameResampleMode(kNoRescaling);
-  EXPECT_TRUE(vp_->PreprocessFrame(video_frame_) != nullptr);
+  EXPECT_TRUE(vp_->PreprocessFrame(video_frame) != nullptr);
 }
 
 #if defined(WEBRTC_IOS)
@@ -133,15 +133,15 @@
   vp_->EnableTemporalDecimation(false);
 
   // Reading test frame
-  std::unique_ptr<uint8_t[]> video_buffer(new uint8_t[frame_length_]);
-  ASSERT_EQ(frame_length_,
-            fread(video_buffer.get(), 1, frame_length_, source_file_));
-  // Using ConvertToI420 to add stride to the image.
-  EXPECT_EQ(0, ConvertToI420(kI420, video_buffer.get(), 0, 0, width_, height_,
-                             0, kVideoRotation_0, &video_frame_));
-  // Cropped source frame that will contain the expected visible region.
-  VideoFrame cropped_source_frame;
-  cropped_source_frame.CopyFrame(video_frame_);
+  rtc::scoped_refptr<webrtc::I420Buffer> buffer =
+      I420Buffer::Create(width_, height_, width_, half_width_, half_width_);
+
+  ASSERT_EQ(static_cast<size_t>(size_y_),
+            fread(buffer->MutableDataY(), 1, size_y_, source_file_));
+  ASSERT_EQ(static_cast<size_t>(size_uv_),
+            fread(buffer->MutableDataU(), 1, size_uv_, source_file_));
+  ASSERT_EQ(static_cast<size_t>(size_uv_),
+            fread(buffer->MutableDataV(), 1, size_uv_, source_file_));
 
   for (uint32_t run_idx = 0; run_idx < NumRuns; run_idx++) {
     // Initiate test timer.
@@ -149,48 +149,37 @@
 
     // Init the sourceFrame with a timestamp.
     int64_t time_start_ms = time_start / rtc::kNumNanosecsPerMillisec;
-    video_frame_.set_render_time_ms(time_start_ms);
-    video_frame_.set_timestamp(time_start_ms * 90);
+    VideoFrame video_frame(buffer, time_start_ms * 90, time_start_ms,
+                           webrtc::kVideoRotation_0);
 
     // Test scaling to different sizes: source is of |width|/|height| = 352/288.
     // Pure scaling:
-    TestSize(video_frame_, video_frame_, width_ / 4, height_ / 4, 25.2, vp_);
-    TestSize(video_frame_, video_frame_, width_ / 2, height_ / 2, 28.1, vp_);
+    TestSize(video_frame, buffer, width_ / 4, height_ / 4, 25.2, vp_);
+    TestSize(video_frame, buffer, width_ / 2, height_ / 2, 28.1, vp_);
     // No resampling:
-    TestSize(video_frame_, video_frame_, width_, height_, -1, vp_);
-    TestSize(video_frame_, video_frame_, 2 * width_, 2 * height_, 32.2, vp_);
+    TestSize(video_frame, buffer, width_, height_, -1, vp_);
+    TestSize(video_frame, buffer, 2 * width_, 2 * height_, 32.2, vp_);
 
     // Scaling and cropping. The cropped source frame is the largest center
     // aligned region that can be used from the source while preserving aspect
     // ratio.
-    CropFrame(video_buffer.get(), width_, height_, 0, 56, 352, 176,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 100, 50, 24.0, vp_);
-
-    CropFrame(video_buffer.get(), width_, height_, 0, 30, 352, 225,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 400, 256, 31.3, vp_);
-
-    CropFrame(video_buffer.get(), width_, height_, 68, 0, 216, 288,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 480, 640, 32.15, vp_);
-
-    CropFrame(video_buffer.get(), width_, height_, 0, 12, 352, 264,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 960, 720, 32.2, vp_);
-
-    CropFrame(video_buffer.get(), width_, height_, 0, 44, 352, 198,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 1280, 720, 32.15, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 0, 56, 352, 176),
+             100, 50, 24.0, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 0, 30, 352, 225),
+             400, 256, 31.3, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 68, 0, 216, 288),
+             480, 640, 32.15, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 0, 12, 352, 264),
+             960, 720, 32.2, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 0, 44, 352, 198),
+             1280, 720, 32.15, vp_);
 
     // Upsampling to odd size.
-    CropFrame(video_buffer.get(), width_, height_, 0, 26, 352, 233,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 501, 333, 32.05, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 0, 26, 352, 233),
+             501, 333, 32.05, vp_);
     // Downsample to odd size.
-    CropFrame(video_buffer.get(), width_, height_, 0, 34, 352, 219,
-              &cropped_source_frame);
-    TestSize(video_frame_, cropped_source_frame, 281, 175, 29.3, vp_);
+    TestSize(video_frame, CropBuffer(buffer, width_, height_, 0, 34, 352, 219),
+             281, 175, 29.3, vp_);
 
     // Stop timer.
     const int64_t runtime =
@@ -229,24 +218,32 @@
   EXPECT_EQ(target_height, (out_frame)->height());
 }
 
-void CropFrame(const uint8_t* source_data,
-               int source_width,
-               int source_height,
-               int offset_x,
-               int offset_y,
-               int cropped_width,
-               int cropped_height,
-               VideoFrame* cropped_frame) {
-  cropped_frame->CreateEmptyFrame(cropped_width, cropped_height, cropped_width,
-                                  (cropped_width + 1) / 2,
-                                  (cropped_width + 1) / 2);
-  EXPECT_EQ(0,
-            ConvertToI420(kI420, source_data, offset_x, offset_y, source_width,
-                          source_height, 0, kVideoRotation_0, cropped_frame));
+rtc::scoped_refptr<VideoFrameBuffer> CropBuffer(
+    const rtc::scoped_refptr<VideoFrameBuffer>& source_buffer,
+    int source_width,
+    int source_height,
+    int offset_x,
+    int offset_y,
+    int cropped_width,
+    int cropped_height) {
+  // Force even.
+  offset_x &= 1;
+  offset_y &= 1;
+
+  size_t y_start = offset_x + offset_y * source_buffer->StrideY();
+  size_t u_start = (offset_x / 2) + (offset_y / 2) * source_buffer->StrideU();
+  size_t v_start = (offset_x / 2) + (offset_y / 2) * source_buffer->StrideU();
+
+  return rtc::scoped_refptr<VideoFrameBuffer>(
+      new rtc::RefCountedObject<WrappedI420Buffer>(
+          cropped_width, cropped_height, source_buffer->DataY() + y_start,
+          source_buffer->StrideY(), source_buffer->DataU() + u_start,
+          source_buffer->StrideU(), source_buffer->DataV() + v_start,
+          source_buffer->StrideV(), rtc::KeepRefUntilDone(source_buffer)));
 }
 
 void TestSize(const VideoFrame& source_frame,
-              const VideoFrame& cropped_source_frame,
+              const rtc::scoped_refptr<VideoFrameBuffer>& cropped_source_buffer,
               int target_width,
               int target_height,
               double expected_psnr,
@@ -263,12 +260,14 @@
   // Scale |resampled_source_frame| back to the source scale.
   VideoFrame resampled_source_frame;
   resampled_source_frame.CopyFrame(*out_frame);
-  PreprocessFrameAndVerify(resampled_source_frame, cropped_source_frame.width(),
-                           cropped_source_frame.height(), vpm, out_frame);
+  PreprocessFrameAndVerify(resampled_source_frame,
+                           cropped_source_buffer->width(),
+                           cropped_source_buffer->height(), vpm, out_frame);
   WriteProcessedFrameForVisualInspection(resampled_source_frame, *out_frame);
 
   // Compute PSNR against the cropped source frame and check expectation.
-  double psnr = I420PSNR(&cropped_source_frame, out_frame);
+  double psnr =
+      I420PSNR(*cropped_source_buffer, *out_frame->video_frame_buffer());
   EXPECT_GT(psnr, expected_psnr);
   printf(
       "PSNR: %f. PSNR is between source of size %d %d, and a modified "
diff --git a/webrtc/modules/video_processing/test/video_processing_unittest.h b/webrtc/modules/video_processing/test/video_processing_unittest.h
index 3433c6c..6edd72e 100644
--- a/webrtc/modules/video_processing/test/video_processing_unittest.h
+++ b/webrtc/modules/video_processing/test/video_processing_unittest.h
@@ -33,7 +33,6 @@
   static void TearDownTestCase() { Trace::ReturnTrace(); }
   VideoProcessing* vp_;
   FILE* source_file_;
-  VideoFrame video_frame_;
   const int width_;
   const int half_width_;
   const int height_;
diff --git a/webrtc/video/video_encoder_unittest.cc b/webrtc/video/video_encoder_unittest.cc
index 84ac4fd..eb2b450 100644
--- a/webrtc/video/video_encoder_unittest.cc
+++ b/webrtc/video/video_encoder_unittest.cc
@@ -116,22 +116,18 @@
   CountingFakeEncoder fake_encoder_;
   VideoEncoderSoftwareFallbackWrapper fallback_wrapper_;
   VideoCodec codec_ = {};
-  VideoFrame frame_;
+  std::unique_ptr<VideoFrame> frame_;
 };
 
 void VideoEncoderSoftwareFallbackWrapperTest::EncodeFrame() {
-  frame_.CreateEmptyFrame(kWidth, kHeight, kWidth, (kWidth + 1) / 2,
-                          (kWidth + 1) / 2);
-  memset(frame_.video_frame_buffer()->MutableDataY(), 16,
-         frame_.allocated_size(webrtc::kYPlane));
-  memset(frame_.video_frame_buffer()->MutableDataU(), 128,
-         frame_.allocated_size(webrtc::kUPlane));
-  memset(frame_.video_frame_buffer()->MutableDataV(), 128,
-         frame_.allocated_size(webrtc::kVPlane));
-
+  rtc::scoped_refptr<I420Buffer> buffer = I420Buffer::Create(
+      kWidth, kHeight, kWidth, (kWidth + 1) / 2, (kWidth + 1) / 2);
+  buffer->SetToBlack();
   std::vector<FrameType> types(1, kVideoFrameKey);
+
+  frame_.reset(new VideoFrame(buffer, 0, 0, webrtc::kVideoRotation_0));
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            fallback_wrapper_.Encode(frame_, nullptr, &types));
+            fallback_wrapper_.Encode(*frame_, nullptr, &types));
 }
 
 void VideoEncoderSoftwareFallbackWrapperTest::UtilizeFallbackEncoder() {
@@ -225,9 +221,9 @@
 
   // Encoding a frame using the fallback should arrive at the new callback.
   std::vector<FrameType> types(1, kVideoFrameKey);
-  frame_.set_timestamp(frame_.timestamp() + 1000);
+  frame_->set_timestamp(frame_->timestamp() + 1000);
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
-            fallback_wrapper_.Encode(frame_, nullptr, &types));
+            fallback_wrapper_.Encode(*frame_, nullptr, &types));
 
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, fallback_wrapper_.Release());
 }