Update VideoFrameBuffer-related methods to not use references to scoped_refptr.

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 133 matching lines @@
   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);
+  // TODO(nisse): This new + Copy looks quite awkward. Consider adding
+  // an alternative I420Buffer::Create method.
   VideoFrame frame1(
-      I420Buffer::Copy(new rtc::RefCountedObject<webrtc::WrappedI420Buffer>(
-          width, height,
-          buffer_y, stride_y,
-          buffer_u, stride_u,
-          buffer_v, stride_v,
-          rtc::Callback0<void>([](){}))),
+      I420Buffer::Copy(*rtc::scoped_refptr<VideoFrameBuffer>(

[nisse-webrtc, 2016/11/10 15:19:54]

This was a bit subtle. Just creating a temporary RefCountedObject seems to leak
that object. Constructing a temporary scoped_refptr to point to it hopefully
fixes that.

To make this call nicer, should I add a I420Buffer::Copy that takes raw yuvdata
as argument?

+          new rtc::RefCountedObject<webrtc::WrappedI420Buffer>(
+              width, height,
+              buffer_y, stride_y,
+              buffer_u, stride_u,
+              buffer_v, stride_v,
+              rtc::Callback0<void>([](){})))),
       kRotation, 0);
   frame1.set_timestamp(timestamp);
   frame1.set_ntp_time_ms(ntp_time_ms);
   frame1.set_render_time_ms(render_time_ms);
   VideoFrame frame2(frame1);
 
   EXPECT_EQ(frame1.video_frame_buffer(), frame2.video_frame_buffer());
   EXPECT_EQ(frame1.video_frame_buffer()->DataY(),
             frame2.video_frame_buffer()->DataY());
   EXPECT_EQ(frame1.video_frame_buffer()->DataU(),
@@ skipping 33 matching lines @@
   frame.set_render_time_ms(20);
   EXPECT_EQ(20, frame.render_time_ms());
 }
 
 TEST(TestI420FrameBuffer, Copy) {
   rtc::scoped_refptr<I420Buffer> buf1(
       I420Buffer::Create(20, 10));
   memset(buf1->MutableDataY(), 1, 200);
   memset(buf1->MutableDataU(), 2, 50);
   memset(buf1->MutableDataV(), 3, 50);
-  rtc::scoped_refptr<I420Buffer> buf2 = I420Buffer::Copy(buf1);
+  rtc::scoped_refptr<I420Buffer> buf2 = I420Buffer::Copy(*buf1);
   EXPECT_TRUE(test::FrameBufsEqual(buf1, buf2));
 }
 
 TEST(TestI420FrameBuffer, Scale) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(200, 100);
 
   // Pure scaling, no cropping.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(150, 75));
 
-  scaled_buffer->ScaleFrom(buf);
+  scaled_buffer->ScaleFrom(*buf);
   CheckCrop(*scaled_buffer, 0.0, 0.0, 1.0, 1.0);
 }
 
 TEST(TestI420FrameBuffer, CropXCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(200, 100);
 
   // Pure center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
-  scaled_buffer->CropAndScaleFrom(buf, 50, 0, 100, 100);
+  scaled_buffer->CropAndScaleFrom(*buf, 50, 0, 100, 100);
   CheckCrop(*scaled_buffer, 0.25, 0.0, 0.5, 1.0);
 }
 
 TEST(TestI420FrameBuffer, CropXNotCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(200, 100);
 
   // Non-center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
-  scaled_buffer->CropAndScaleFrom(buf, 25, 0, 100, 100);
+  scaled_buffer->CropAndScaleFrom(*buf, 25, 0, 100, 100);
   CheckCrop(*scaled_buffer, 0.125, 0.0, 0.5, 1.0);
 }
 
 TEST(TestI420FrameBuffer, CropYCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(100, 200);
 
   // Pure center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
-  scaled_buffer->CropAndScaleFrom(buf, 0, 50, 100, 100);
+  scaled_buffer->CropAndScaleFrom(*buf, 0, 50, 100, 100);
   CheckCrop(*scaled_buffer, 0.0, 0.25, 1.0, 0.5);
 }
 
 TEST(TestI420FrameBuffer, CropYNotCenter) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(100, 200);
 
   // Non-center cropping, no scaling.
   rtc::scoped_refptr<I420Buffer> scaled_buffer(
       I420Buffer::Create(100, 100));
 
-  scaled_buffer->CropAndScaleFrom(buf, 0, 25, 100, 100);
+  scaled_buffer->CropAndScaleFrom(*buf, 0, 25, 100, 100);
   CheckCrop(*scaled_buffer, 0.0, 0.125, 1.0, 0.5);
 }
 
 TEST(TestI420FrameBuffer, CropAndScale16x9) {
   rtc::scoped_refptr<I420Buffer> buf = CreateGradient(640, 480);
 
   // 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);
+  scaled_buffer->CropAndScaleFrom(*buf);
   CheckCrop(*scaled_buffer, 0.0, 0.125, 1.0, 0.75);
 }
 
 class TestI420BufferRotate
     : public ::testing::TestWithParam<webrtc::VideoRotation> {};
 
 TEST_P(TestI420BufferRotate, Rotates) {
   rtc::scoped_refptr<VideoFrameBuffer> buffer = CreateGradient(640, 480);
   rtc::scoped_refptr<VideoFrameBuffer> rotated_buffer =
       I420Buffer::Rotate(buffer, GetParam());
   CheckRotate(640, 480, GetParam(), *rotated_buffer);
 }
 
 INSTANTIATE_TEST_CASE_P(Rotate, TestI420BufferRotate,
                         ::testing::Values(kVideoRotation_0,
                                           kVideoRotation_90,
                                           kVideoRotation_180,
                                           kVideoRotation_270));
 
 }  // namespace webrtc