Rewrite CreateBlackFrame in webrtcvideoengine.

webrtc/modules/video_coding/utility/quality_scaler_unittest.cc

 /*
  *  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 24 matching lines @@
 class QualityScalerTest : public ::testing::Test {
  protected:
   enum ScaleDirection {
     kKeepScaleAtHighQp,
     kScaleDown,
     kScaleDownAboveHighQp,
     kScaleUp
   };
 
   QualityScalerTest() {
-    input_frame_ = rtc::scoped_refptr<VideoFrameBuffer>(
-        new rtc::RefCountedObject<I420Buffer>(kWidth, kHeight));
+    input_frame_ = I420Buffer::Create(kWidth, kHeight);
     qs_.Init(kLowQpThreshold, kHighQp, 0, 0, 0, kFramerate);
     qs_.OnEncodeFrame(input_frame_->width(), input_frame_->height());
   }
 
   bool TriggerScale(ScaleDirection scale_direction) {
     qs_.OnEncodeFrame(input_frame_->width(), input_frame_->height());
     int initial_width = qs_.GetScaledResolution().width;
     for (int i = 0; i < kFramerate * kNumSeconds; ++i) {
       switch (scale_direction) {
         case kScaleUp:
@@ skipping 155 matching lines @@
 }
 
 TEST_F(QualityScalerTest, ContinuouslyDownscalesByHalfDimensionsAndBackUp) {
   ContinuouslyDownscalesByHalfDimensionsAndBackUp();
 }
 
 TEST_F(QualityScalerTest,
        ContinuouslyDownscalesOddResolutionsByHalfDimensionsAndBackUp) {
   const int kOddWidth = 517;
   const int kOddHeight = 1239;
-  input_frame_ = rtc::scoped_refptr<VideoFrameBuffer>(
-      new rtc::RefCountedObject<I420Buffer>(kOddWidth, kOddHeight));
+  input_frame_ = I420Buffer::Create(kOddWidth, kOddHeight);
   ContinuouslyDownscalesByHalfDimensionsAndBackUp();
 }
 
 void QualityScalerTest::DoesNotDownscaleFrameDimensions(int width, int height) {
-  input_frame_ = rtc::scoped_refptr<VideoFrameBuffer>(
-      new rtc::RefCountedObject<I420Buffer>(width, height));
+  input_frame_ = I420Buffer::Create(width, height);
 
   for (int i = 0; i < kFramerate * kNumSeconds; ++i) {
     qs_.ReportDroppedFrame();
     qs_.OnEncodeFrame(input_frame_->width(), input_frame_->height());
     ASSERT_EQ(input_frame_->width(), qs_.GetScaledResolution().width)
         << "Unexpected scale of minimal-size frame.";
   }
 }
 
 TEST_F(QualityScalerTest, DoesNotDownscaleFrom1PxWidth) {
@@ skipping 15 matching lines @@
 
 TEST_F(QualityScalerTest, DoesNotDownscaleBelow2xDefaultMinDimensionsHeight) {
   DoesNotDownscaleFrameDimensions(
       1000, 2 * kMinDownscaleDimension - 1);
 }
 
 TEST_F(QualityScalerTest, DownscaleToVgaOnLowInitialBitrate) {
   static const int kWidth720p = 1280;
   static const int kHeight720p = 720;
   static const int kInitialBitrateKbps = 300;
-  input_frame_ = rtc::scoped_refptr<VideoFrameBuffer>(
-      new rtc::RefCountedObject<I420Buffer>(kWidth720p, kHeight720p));
+  input_frame_ = I420Buffer::Create(kWidth720p, kHeight720p);
   qs_.Init(kLowQpThreshold, kDisabledBadQpThreshold, kInitialBitrateKbps,
            kWidth720p, kHeight720p, kFramerate);
   qs_.OnEncodeFrame(input_frame_->width(), input_frame_->height());
   int init_width = qs_.GetScaledResolution().width;
   int init_height = qs_.GetScaledResolution().height;
   EXPECT_EQ(640, init_width);
   EXPECT_EQ(360, init_height);
 }
 
 TEST_F(QualityScalerTest, DownscaleToQvgaOnLowerInitialBitrate) {
   static const int kWidth720p = 1280;
   static const int kHeight720p = 720;
   static const int kInitialBitrateKbps = 200;
-  input_frame_ = rtc::scoped_refptr<VideoFrameBuffer>(
-      new rtc::RefCountedObject<I420Buffer>(kWidth720p, kHeight720p));
+  input_frame_ = I420Buffer::Create(kWidth720p, kHeight720p);
   qs_.Init(kLowQpThreshold, kDisabledBadQpThreshold, kInitialBitrateKbps,
            kWidth720p, kHeight720p, kFramerate);
   qs_.OnEncodeFrame(input_frame_->width(), input_frame_->height());
   int init_width = qs_.GetScaledResolution().width;
   int init_height = qs_.GetScaledResolution().height;
   EXPECT_EQ(320, init_width);
   EXPECT_EQ(180, init_height);
 }
 
 TEST_F(QualityScalerTest, DownscaleAfterMeasuredSecondsThenSlowerBackUp) {
@@ skipping 54 matching lines @@
   EXPECT_LT(initial_res.width, qs_.GetScaledResolution().width);
   EXPECT_LT(initial_res.height, qs_.GetScaledResolution().height);
 }
 
 void QualityScalerTest::DownscaleEndsAt(int input_width,
                                         int input_height,
                                         int end_width,
                                         int end_height) {
   // Create a frame with 2x expected end width/height to verify that we can
   // scale down to expected end width/height.
-  input_frame_ = rtc::scoped_refptr<VideoFrameBuffer>(
-      new rtc::RefCountedObject<I420Buffer>(input_width, input_height));
+  input_frame_ = I420Buffer::Create(input_width, input_height);
 
   int last_width = input_width;
   int last_height = input_height;
   // Drop all frames to force-trigger downscaling.
   while (true) {
     TriggerScale(kScaleDown);
     QualityScaler::Resolution res = qs_.GetScaledResolution();
     if (last_width == res.width) {
       EXPECT_EQ(last_height, res.height);
       EXPECT_EQ(end_width, res.width);
@@ skipping 15 matching lines @@
 
 TEST_F(QualityScalerTest, DownscalesFrom1280x720To320x180) {
   DownscaleEndsAt(1280, 720, 320, 180);
 }
 
 TEST_F(QualityScalerTest, DoesntDownscaleInitialQvga) {
   DownscaleEndsAt(320, 180, 320, 180);
 }
 
 }  // namespace webrtc