Revert of Move MutableDataY{,U,V} methods to I420Buffer only.

webrtc/modules/video_coding/codecs/vp8/simulcast_unittest.h

 /*
  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 218 matching lines @@
                        int stride) {
     for (int i = 0; i < height; i++, data += stride) {
       // Setting allocated area to zero - setting only image size to
       // requested values - will make it easier to distinguish between image
       // size and frame size (accounting for stride).
       memset(data, value, width);
       memset(data + width, 0, stride - width);
     }
   }
 
-  // Fills in an I420Buffer from |plane_colors|.
-  static void CreateImage(const rtc::scoped_refptr<I420Buffer>& buffer,
+  // Fills in an VideoFrameBuffer from |plane_colors|.
+  static void CreateImage(const rtc::scoped_refptr<VideoFrameBuffer>& buffer,
                           int plane_colors[kNumOfPlanes]) {
     int width = buffer->width();
     int height = buffer->height();
     int chroma_width = (width + 1) / 2;
     int chroma_height = (height + 1) / 2;
 
     SetPlane(buffer->MutableDataY(), plane_colors[0],
              width, height, buffer->StrideY());
 
     SetPlane(buffer->MutableDataU(), plane_colors[1],
@@ skipping 59 matching lines @@
  protected:
   virtual void SetUp() { SetUpCodec(kDefaultTemporalLayerProfile); }
 
   virtual void SetUpCodec(const int* temporal_layer_profile) {
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback_);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback_);
     DefaultSettings(&settings_, temporal_layer_profile);
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     EXPECT_EQ(0, decoder_->InitDecode(&settings_, 1));
     int half_width = (kDefaultWidth + 1) / 2;
-    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));
+    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));
   }
 
   virtual void TearDown() {
     encoder_->Release();
     decoder_->Release();
   }
 
   void ExpectStreams(FrameType frame_type, int expected_video_streams) {
     ASSERT_GE(expected_video_streams, 0);
     ASSERT_LE(expected_video_streams, kNumberOfSimulcastStreams);
@@ skipping 51 matching lines @@
     }
   }
 
   // We currently expect all active streams to generate a key frame even though
   // a key frame was only requested for some of them.
   void TestKeyFrameRequestsOnAllStreams() {
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
     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() {
     // We should always encode the base layer.
     encoder_->SetRates(kMinBitrates[0] - 1, 30);
     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() {
     // We have just enough to get only the first stream and padding for two.
     encoder_->SetRates(kMinBitrates[0], 30);
     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() {
     // We are just below limit of sending second stream, so we should get
     // the first stream maxed out (at |maxBitrate|), and padding for two.
     encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1] - 1, 30);
     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() {
     // We have just enough to send two streams, so padding for one stream.
     encoder_->SetRates(kTargetBitrates[0] + kMinBitrates[1], 30);
     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() {
     // We are just below limit of sending third stream, so we should get
     // first stream's rate maxed out at |targetBitrate|, second at |maxBitrate|.
     encoder_->SetRates(
         kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2] - 1, 30);
     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() {
     // We have just enough to send all streams.
     encoder_->SetRates(
         kTargetBitrates[0] + kTargetBitrates[1] + kMinBitrates[2], 30);
     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() {
     // We should get three media streams.
     encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1] + kMaxBitrates[2], 30);
     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) {
     // Disable all streams except the last and set the bitrate of the last to
     // 100 kbps. This verifies the way GTP switches to screenshare mode.
     settings_.codecSpecific.VP8.numberOfTemporalLayers = 1;
     settings_.maxBitrate = 100;
     settings_.startBitrate = 100;
     settings_.width = width;
     settings_.height = height;
     for (int i = 0; i < settings_.numberOfSimulcastStreams - 1; ++i) {
       settings_.simulcastStream[i].maxBitrate = 0;
       settings_.simulcastStream[i].width = settings_.width;
       settings_.simulcastStream[i].height = settings_.height;
     }
     // Setting input image to new resolution.
     int half_width = (settings_.width + 1) / 2;
-    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));
+    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));
 
     // The for loop above did not set the bitrate of the highest layer.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1]
         .maxBitrate = 0;
     // The highest layer has to correspond to the non-simulcast resolution.
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].width =
         settings_.width;
     settings_.simulcastStream[settings_.numberOfSimulcastStreams - 1].height =
         settings_.height;
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
 
     // Encode one frame and verify.
     encoder_->SetRates(kMaxBitrates[0] + kMaxBitrates[1], 30);
     std::vector<FrameType> frame_types(kNumberOfSimulcastStreams,
                                        kVideoFrameDelta);
     EXPECT_CALL(
         encoder_callback_,
         OnEncodedImage(AllOf(Field(&EncodedImage::_frameType, kVideoFrameKey),
                              Field(&EncodedImage::_encodedWidth, width),
                              Field(&EncodedImage::_encodedHeight, height)),
                        _, _))
         .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);
     // Start at the lowest bitrate for enabling base stream.
     settings_.startBitrate = kMinBitrates[0];
     EXPECT_EQ(0, encoder_->InitEncode(&settings_, 1, 1200));
     encoder_->SetRates(settings_.startBitrate, 30);
     ExpectStreams(kVideoFrameKey, 1);
     // Resize |input_frame_| to the new resolution.
     half_width = (settings_.width + 1) / 2;
-    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));
+    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));
   }
 
   void TestSwitchingToOneStream() { SwitchingToOneStream(1024, 768); }
 
   void TestSwitchingToOneOddStream() { SwitchingToOneStream(1023, 769); }
 
   void TestSwitchingToOneSmallStream() { SwitchingToOneStream(4, 4); }
 
   void TestRPSIEncoder() {
     Vp8TestEncodedImageCallback encoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
 
     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;
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(0, temporal_layer);
     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);
     EXPECT_FALSE(layer_sync);
 
     CodecSpecificInfo codec_specific;
     codec_specific.codecType = kVideoCodecVP8;
     codec_specific.codecSpecific.VP8.hasReceivedRPSI = true;
 
     // 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);
 
     EXPECT_EQ(0, temporal_layer);
     EXPECT_TRUE(layer_sync);
 
     // 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);
 
     EXPECT_EQ(2, temporal_layer);
     // The previous frame was a base layer sync (since it was a frame that
     // only predicts from key frame and hence resets the temporal pattern),
     // so this frame (the next one) must have |layer_sync| set to true.
     EXPECT_TRUE(layer_sync);
   }
 
   void TestRPSIEncodeDecode() {
     Vp8TestEncodedImageCallback encoder_callback;
     Vp8TestDecodedImageCallback decoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback);
 
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     // Set color.
     int plane_offset[kNumOfPlanes];
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(input_buffer_, plane_offset);
+    CreateImage(input_frame_.video_frame_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;
     encoder_callback.GetLastEncodedFrameInfo(&picture_id, &temporal_layer,
                                              &layer_sync, 0);
     EXPECT_EQ(0, temporal_layer);
     EXPECT_TRUE(layer_sync);
     int key_frame_picture_id = picture_id;
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(input_buffer_, plane_offset);
-    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
+    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));
 
     // Change color.
     plane_offset[kYPlane] += 1;
     plane_offset[kUPlane] += 1;
     plane_offset[kVPlane] += 1;
-    CreateImage(input_buffer_, plane_offset);
+    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));
+    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_buffer_, plane_offset);
+    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));
+    input_frame_.set_timestamp(input_frame_.timestamp() + 3000);
+    EXPECT_EQ(0, encoder_->Encode(input_frame_, NULL, NULL));
 
     CodecSpecificInfo codec_specific;
     codec_specific.codecType = kVideoCodecVP8;
     codec_specific.codecSpecific.VP8.hasReceivedRPSI = true;
     // Must match last key frame to trigger.
     codec_specific.codecSpecific.VP8.pictureIdRPSI = key_frame_picture_id;
 
     // Change color back to original.
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(input_buffer_, plane_offset);
+    CreateImage(input_frame_.video_frame_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);
     decoder_->Decode(encoded_frame, false, NULL);
     encoder_callback.GetLastEncodedFrame(&encoded_frame);
     decoder_->Decode(encoded_frame, false, NULL);
     EXPECT_EQ(2, decoder_callback.DecodedFrames());
   }
 
   // Test the layer pattern and sync flag for various spatial-temporal patterns.
   // 3-3-3 pattern: 3 temporal layers for all spatial streams, so same
   // temporal_layer id and layer_sync is expected for all streams.
   void TestSaptioTemporalLayers333PatternEncoder() {
     Vp8TestEncodedImageCallback encoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     int expected_temporal_idx[3] = {-1, -1, -1};
     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(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
   }
 
   // Test the layer pattern and sync flag for various spatial-temporal patterns.
   // 3-2-1 pattern: 3 temporal layers for lowest resolution, 2 for middle, and
   // 1 temporal layer for highest resolution.
   // For this profile, we expect the temporal index pattern to be:
   // 1st stream: 0, 2, 1, 2, ....
   // 2nd stream: 0, 1, 0, 1, ...
   // 3rd stream: -1, -1, -1, -1, ....
   // Regarding the 3rd stream, note that a stream/encoder with 1 temporal layer
   // should always have temporal layer idx set to kNoTemporalIdx = -1.
   // Since CodecSpecificInfoVP8.temporalIdx is uint8_t, this will wrap to 255.
   // TODO(marpan): Although this seems safe for now, we should fix this.
   void TestSpatioTemporalLayers321PatternEncoder() {
     int temporal_layer_profile[3] = {3, 2, 1};
     SetUpCodec(temporal_layer_profile);
     Vp8TestEncodedImageCallback encoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
 
     int expected_temporal_idx[3] = {-1, -1, -1};
     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(
         &encoder_callback, expected_temporal_idx, expected_layer_sync, 3);
   }
 
   void TestStrideEncodeDecode() {
     Vp8TestEncodedImageCallback encoder_callback;
     Vp8TestDecodedImageCallback decoder_callback;
     encoder_->RegisterEncodeCompleteCallback(&encoder_callback);
     decoder_->RegisterDecodeCompleteCallback(&decoder_callback);
 
     encoder_->SetRates(kMaxBitrates[2], 30);  // To get all three streams.
     // Setting two (possibly) problematic use cases for stride:
     // 1. stride > width 2. stride_y != stride_uv/2
     int stride_y = kDefaultWidth + 20;
     int stride_uv = ((kDefaultWidth + 1) / 2) + 5;
-    input_buffer_ = I420Buffer::Create(kDefaultWidth, kDefaultHeight, stride_y,
-                                       stride_uv, stride_uv);
-    input_frame_.reset(
-        new VideoFrame(input_buffer_, 0, 0, webrtc::kVideoRotation_0));
-
+    input_frame_.CreateEmptyFrame(kDefaultWidth, kDefaultHeight, stride_y,
+                                  stride_uv, stride_uv);
     // Set color.
     int plane_offset[kNumOfPlanes];
     plane_offset[kYPlane] = kColorY;
     plane_offset[kUPlane] = kColorU;
     plane_offset[kVPlane] = kColorV;
-    CreateImage(input_buffer_, plane_offset);
+    CreateImage(input_frame_.video_frame_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_buffer_, plane_offset);
-    input_frame_->set_timestamp(input_frame_->timestamp() + 3000);
-    EXPECT_EQ(0, encoder_->Encode(*input_frame_, NULL, NULL));
+    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));
 
     EncodedImage encoded_frame;
     // Only encoding one frame - so will be a key frame.
     encoder_callback.GetLastEncodedKeyFrame(&encoded_frame);
     EXPECT_EQ(0, decoder_->Decode(encoded_frame, false, NULL));
     encoder_callback.GetLastEncodedFrame(&encoded_frame);
     decoder_->Decode(encoded_frame, false, NULL);
     EXPECT_EQ(2, decoder_callback.DecodedFrames());
   }
 
@@ skipping 19 matching lines @@
       }
       ++stream;
     }
   }
 
   std::unique_ptr<VP8Encoder> encoder_;
   MockEncodedImageCallback encoder_callback_;
   std::unique_ptr<VP8Decoder> decoder_;
   MockDecodedImageCallback decoder_callback_;
   VideoCodec settings_;
-  rtc::scoped_refptr<I420Buffer> input_buffer_;
-  std::unique_ptr<VideoFrame> input_frame_;
+  VideoFrame input_frame_;
 };
 
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_SIMULCAST_UNITTEST_H_