Delete webrtc::VideoFrame::CreateEmptyFrame.

webrtc/common_video/i420_video_frame_unittest.cc

 /*
  *  Copyright (c) 2012 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 73 matching lines @@
   EXPECT_EQ(kVideoRotation_0, frame.rotation());
 }
 
 TEST(TestVideoFrame, CopiesInitialFrameWithoutCrashing) {
   VideoFrame frame;
   VideoFrame frame2;
   frame2.CopyFrame(frame);
 }
 
 TEST(TestVideoFrame, WidthHeightValues) {
-  VideoFrame frame;
+  VideoFrame frame(I420Buffer::Create(10, 10, 10, 14, 90),
+                   webrtc::kVideoRotation_0,
+                   789 * rtc::kNumMicrosecsPerMillisec);
   const int valid_value = 10;
-  frame.CreateEmptyFrame(10, 10, 10, 14, 90);
   EXPECT_EQ(valid_value, frame.width());
   EXPECT_EQ(valid_value, frame.height());
   frame.set_timestamp(123u);
   EXPECT_EQ(123u, frame.timestamp());
   frame.set_ntp_time_ms(456);
   EXPECT_EQ(456, frame.ntp_time_ms());
-  frame.set_render_time_ms(789);
   EXPECT_EQ(789, frame.render_time_ms());
 }
 
 TEST(TestVideoFrame, CopyFrame) {
-  uint32_t timestamp = 1;
-  int64_t ntp_time_ms = 2;
-  int64_t render_time_ms = 3;
   int stride_y = 15;
   int stride_u = 10;
   int stride_v = 10;
   int width = 15;
   int height = 15;
   // Copy frame.
   VideoFrame small_frame;

[magjed_webrtc, 2016/09/28 14:03:04]

Don't you need to create an I420Buffer here?

[nisse-webrtc, 2016/09/29 06:32:44]

No, CopyFrame allocates a new buffer. Which makes this test a bit pointless. (I
have a followup cl in the works, deleting CopyFrame, replacing few remaining
uses by ShallowCopy. That cl also deletes this test).

[magjed_webrtc, 2016/09/29 15:39:04]

I see.

-  small_frame.CreateEmptyFrame(width, height,
-                               stride_y, stride_u, stride_v);
-  small_frame.set_timestamp(timestamp);
-  small_frame.set_ntp_time_ms(ntp_time_ms);
-  small_frame.set_render_time_ms(render_time_ms);
   const int kSizeY = 400;
   const int kSizeU = 100;
   const int kSizeV = 100;
   const VideoRotation kRotation = kVideoRotation_270;
   uint8_t buffer_y[kSizeY];
   uint8_t buffer_u[kSizeU];
   uint8_t buffer_v[kSizeV];
   memset(buffer_y, 16, kSizeY);
   memset(buffer_u, 8, kSizeU);
   memset(buffer_v, 4, kSizeV);
@@ skipping 74 matching lines @@
 }
 
 TEST(TestVideoFrame, CopyBuffer) {
   VideoFrame frame1, frame2;
   int width = 15;
   int height = 15;
   int stride_y = 15;
   int stride_uv = 10;
   const int kSizeY = 225;
   const int kSizeUv = 80;
-  frame2.CreateEmptyFrame(width, height,
-                          stride_y, stride_uv, stride_uv);
+

[magjed_webrtc, 2016/09/28 14:03:03]

ditto: don't you need to create the I40Buffer?

[nisse-webrtc, 2016/09/29 06:32:44]

No, .CreateFrame(various pointers) always allocates a new framebuffer now.

(And I'd like to delete CreateFrame too, but not sure what the right replacement
is. Maybe an I420Buffer::Create with additional arguments).

   uint8_t buffer_y[kSizeY];
   uint8_t buffer_u[kSizeUv];
   uint8_t buffer_v[kSizeUv];
   memset(buffer_y, 16, kSizeY);
   memset(buffer_u, 8, kSizeUv);
   memset(buffer_v, 4, kSizeUv);
   frame2.CreateFrame(buffer_y, buffer_u, buffer_v,
                      width, height, stride_y, stride_uv, stride_uv,
                      kVideoRotation_0);
   // Expect exactly the same pixel data.
   EXPECT_TRUE(test::EqualPlane(buffer_y, frame2.video_frame_buffer()->DataY(),
                                stride_y, 15, 15));
   EXPECT_TRUE(test::EqualPlane(buffer_u, frame2.video_frame_buffer()->DataU(),
                                stride_uv, 8, 8));
   EXPECT_TRUE(test::EqualPlane(buffer_v, frame2.video_frame_buffer()->DataV(),
                                stride_uv, 8, 8));
 }
 
-TEST(TestVideoFrame, FailToReuseAllocation) {
-  VideoFrame frame1;
-  frame1.CreateEmptyFrame(640, 320, 640, 320, 320);
-  const uint8_t* y = frame1.video_frame_buffer()->DataY();
-  const uint8_t* u = frame1.video_frame_buffer()->DataU();
-  const uint8_t* v = frame1.video_frame_buffer()->DataV();
-  // Make a shallow copy of |frame1|.
-  VideoFrame frame2(frame1.video_frame_buffer(), 0, 0, kVideoRotation_0);
-  frame1.CreateEmptyFrame(640, 320, 640, 320, 320);
-  EXPECT_NE(y, frame1.video_frame_buffer()->DataY());
-  EXPECT_NE(u, frame1.video_frame_buffer()->DataU());
-  EXPECT_NE(v, frame1.video_frame_buffer()->DataV());
-}
-
 TEST(TestVideoFrame, TextureInitialValues) {
   test::FakeNativeHandle* handle = new test::FakeNativeHandle();
   VideoFrame frame = test::FakeNativeHandle::CreateFrame(
       handle, 640, 480, 100, 10, webrtc::kVideoRotation_0);
   EXPECT_EQ(640, frame.width());
   EXPECT_EQ(480, frame.height());
   EXPECT_EQ(100u, frame.timestamp());
   EXPECT_EQ(10, frame.render_time_ms());
   ASSERT_TRUE(frame.video_frame_buffer() != nullptr);
   EXPECT_EQ(handle, frame.video_frame_buffer()->native_handle());
@@ skipping 74 matching lines @@
 
   // Center crop to 640 x 360 (16/9 aspect), then scale down by 2.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(320, 180));
 
   scaled_buffer->CropAndScaleFrom(buf);
   CheckCrop(scaled_buffer, 0.0, 0.125, 1.0, 0.75);
 }
 
 }  // namespace webrtc