Re-land "Convert native handles to buffers before encoding."

webrtc/video/video_send_stream_tests.cc

 /*
  *  Copyright (c) 2013 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.
  */
 #include <algorithm>  // max
@@ skipping 12 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/event_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/ref_count.h"
 #include "webrtc/system_wrappers/interface/sleep.h"
 #include "webrtc/system_wrappers/interface/thread_wrapper.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/configurable_frame_size_encoder.h"
+#include "webrtc/test/fake_texture_frame.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video/transport_adapter.h"
 #include "webrtc/video_frame.h"
 #include "webrtc/video_send_stream.h"
 
 namespace webrtc {
 
 enum VideoFormat { kGeneric, kVP8, };
 
 void ExpectEqualFrames(const VideoFrame& frame1, const VideoFrame& frame2);
 void ExpectEqualTextureFrames(const VideoFrame& frame1,
                               const VideoFrame& frame2);
 void ExpectEqualBufferFrames(const VideoFrame& frame1,
                              const VideoFrame& frame2);
 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
                              const std::vector<VideoFrame>& frames2);
 VideoFrame CreateVideoFrame(int width, int height, uint8_t data);
 
-class FakeNativeHandle {
- public:
-  FakeNativeHandle() {}
-  ~FakeNativeHandle() {}
-};
-
-void DeleteNativeHandle(FakeNativeHandle* handle) {
-  delete handle;
-}
-
 class VideoSendStreamTest : public test::CallTest {
  protected:
   void TestNackRetransmission(uint32_t retransmit_ssrc,
                               uint8_t retransmit_payload_type);
   void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
 };
 
 TEST_F(VideoSendStreamTest, CanStartStartedStream) {
   test::NullTransport transport;
   Call::Config call_config(&transport);
@@ skipping 1004 matching lines @@
   CreateSendConfig(1);
   FrameObserver observer;
   send_config_.pre_encode_callback = &observer;
   CreateStreams();
 
   // Prepare five input frames. Send ordinary VideoFrame and texture frames
   // alternatively.
   std::vector<VideoFrame> input_frames;
   int width = static_cast<int>(encoder_config_.streams[0].width);
   int height = static_cast<int>(encoder_config_.streams[0].height);
-  FakeNativeHandle* handle1 = new FakeNativeHandle();
-  FakeNativeHandle* handle2 = new FakeNativeHandle();
-  FakeNativeHandle* handle3 = new FakeNativeHandle();
-  input_frames.push_back(VideoFrame(handle1, width, height, 1, 1,
-                                    kVideoRotation_0,
-                                    rtc::Bind(&DeleteNativeHandle, handle1)));
-  input_frames.push_back(VideoFrame(handle2, width, height, 2, 2,
-                                    kVideoRotation_0,
-                                    rtc::Bind(&DeleteNativeHandle, handle2)));
+  test::FakeNativeHandle* handle1 = new test::FakeNativeHandle();
+  test::FakeNativeHandle* handle2 = new test::FakeNativeHandle();
+  test::FakeNativeHandle* handle3 = new test::FakeNativeHandle();
+  input_frames.push_back(test::CreateFakeNativeHandleFrame(
+      handle1, width, height, 1, 1, kVideoRotation_0));
+  input_frames.push_back(test::CreateFakeNativeHandleFrame(
+      handle2, width, height, 2, 2, kVideoRotation_0));
   input_frames.push_back(CreateVideoFrame(width, height, 3));
   input_frames.push_back(CreateVideoFrame(width, height, 4));
-  input_frames.push_back(VideoFrame(handle3, width, height, 5, 5,
-                                    kVideoRotation_0,
-                                    rtc::Bind(&DeleteNativeHandle, handle3)));
+  input_frames.push_back(test::CreateFakeNativeHandleFrame(
+      handle3, width, height, 5, 5, kVideoRotation_0));
 
   send_stream_->Start();
   for (size_t i = 0; i < input_frames.size(); i++) {
     send_stream_->Input()->IncomingCapturedFrame(input_frames[i]);
     // Do not send the next frame too fast, so the frame dropper won't drop it.
     if (i < input_frames.size() - 1)
       SleepMs(1000 / encoder_config_.streams[0].max_framerate);
     // Wait until the output frame is received before sending the next input
     // frame. Or the previous input frame may be replaced without delivering.
     observer.WaitOutputFrame();
@@ skipping 648 matching lines @@
         const std::vector<VideoReceiveStream*>& receive_streams) override {
       send_stream_ = send_stream;
     }
 
     VideoSendStream* send_stream_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc