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

webrtc/modules/video_capture/test/video_capture_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 402 matching lines @@
     process_module_->Start();
     process_module_->RegisterModule(capture_module_);
 
     VideoCaptureCapability capability;
     capability.width = kTestWidth;
     capability.height = kTestHeight;
     capability.rawType = webrtc::kVideoYV12;
     capability.maxFPS = kTestFramerate;
     capture_callback_.SetExpectedCapability(capability);
 
-    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,
+    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,
            ((kTestWidth + 1) / 2) * ((kTestHeight + 1) / 2));
-    memset(buffer->MutableDataV(), 127,
+    memset(test_frame_.video_frame_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_);
     capture_module_->EnableFrameRateCallback(true);
     capture_module_->EnableNoPictureAlarm(true);
   }
 
   void TearDown() {
     process_module_->Stop();
   }
 
   webrtc::VideoCaptureExternal* capture_input_interface_;
   rtc::scoped_refptr<VideoCaptureModule> capture_module_;
   std::unique_ptr<webrtc::ProcessThread> process_module_;
-  std::unique_ptr<webrtc::VideoFrame> test_frame_;
+  webrtc::VideoFrame test_frame_;
   TestVideoCaptureCallback capture_callback_;
   TestVideoCaptureFeedBack capture_feedback_;
 };
 
 // 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.
 // Flaky on Win32, see webrtc:3270.
 #if defined(WEBRTC_WIN) || defined(WEBRTC_MAC)
 #define MAYBE_FrameRate DISABLED_FrameRate
 #else
 #define MAYBE_FrameRate FrameRate
 #endif
 TEST_F(VideoCaptureExternalTest, MAYBE_FrameRate) {
   uint64_t testTime = 3 * rtc::kNumNanosecsPerSec;
   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 &&
               capture_feedback_.frame_rate() <= 10);
   SleepMs(500);
   EXPECT_EQ(webrtc::Raised, capture_feedback_.alarm());
 
   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);
   }
   EXPECT_EQ(webrtc::Cleared, capture_feedback_.alarm());
   // Frame rate might be less than 33 since we have paused providing
   // frames for a while.
   EXPECT_TRUE(capture_feedback_.frame_rate() >= 25 &&
               capture_feedback_.frame_rate() <= 33);
 }
 
 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));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_90);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_180));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_180);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
   EXPECT_EQ(0, capture_module_->SetCaptureRotation(webrtc::kVideoRotation_270));
   capture_callback_.SetExpectedCaptureRotation(webrtc::kVideoRotation_270);
   EXPECT_EQ(0, capture_input_interface_->IncomingFrame(test_buffer.get(),
     length, capture_callback_.capability(), 0));
 }