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

webrtc/video_engine/vie_capturer_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.
  */
 
 // This file includes unit tests for ViECapturer.
 
 #include "webrtc/video_engine/vie_capturer.h"
 
 #include <vector>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common.h"
 #include "webrtc/modules/utility/interface/mock/mock_process_thread.h"
 #include "webrtc/modules/video_capture/include/mock/mock_video_capture.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/event_wrapper.h"
 #include "webrtc/system_wrappers/interface/ref_count.h"
 #include "webrtc/system_wrappers/interface/scoped_vector.h"
+#include "webrtc/test/fake_texture_frame.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::WithArg;
 
 // If an output frame does not arrive in 500ms, the test will fail.
 #define FRAME_TIMEOUT_MS 500
 
@@ skipping 115 matching lines @@
 
   AddInputFrame(input_frames_[0]);
   WaitOutputFrame();
   EXPECT_EQ(output_frames_[0]->timestamp(),
             input_frames_[0]->ntp_time_ms() * 90);
 }
 
 TEST_F(ViECapturerTest, TestTextureFrames) {
   const int kNumFrame = 3;
   for (int i = 0 ; i < kNumFrame; ++i) {
-    void* dummy_handle = reinterpret_cast<void*>(i+1);
+    test::FakeNativeHandle* dummy_handle = new test::FakeNativeHandle();
     // Add one to |i| so that width/height > 0.
-    input_frames_.push_back(new VideoFrame(dummy_handle, i + 1, i + 1, i + 1,
-                                           i + 1, webrtc::kVideoRotation_0,
-                                           rtc::Callback0<void>()));
+    input_frames_.push_back(new VideoFrame(test::CreateFakeNativeHandleFrame(
+        dummy_handle, i + 1, i + 1, i + 1, i + 1, webrtc::kVideoRotation_0)));
     AddInputFrame(input_frames_[i]);
     WaitOutputFrame();
     EXPECT_EQ(dummy_handle, output_frames_[i]->native_handle());
   }
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
 }
 
 TEST_F(ViECapturerTest, TestI420Frames) {
   const int kNumFrame = 4;
   std::vector<const uint8_t*> ybuffer_pointers;
   for (int i = 0; i < kNumFrame; ++i) {
     input_frames_.push_back(CreateVideoFrame(static_cast<uint8_t>(i + 1)));
     const VideoFrame* const_input_frame = input_frames_[i];
     ybuffer_pointers.push_back(const_input_frame->buffer(kYPlane));
     AddInputFrame(input_frames_[i]);
     WaitOutputFrame();
   }
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
   // Make sure the buffer is not copied.
   for (int i = 0; i < kNumFrame; ++i)
     EXPECT_EQ(ybuffer_pointers[i], output_frame_ybuffers_[i]);
 }
 
 TEST_F(ViECapturerTest, TestI420FrameAfterTextureFrame) {
-  void* dummy_handle = &input_frames_;
-  input_frames_.push_back(new VideoFrame(dummy_handle, 1, 1, 1, 1,
-                                         webrtc::kVideoRotation_0,
-                                         rtc::Callback0<void>()));
+  test::FakeNativeHandle* dummy_handle = new test::FakeNativeHandle();
+  input_frames_.push_back(new VideoFrame(test::CreateFakeNativeHandleFrame(
+      dummy_handle, 1, 1, 1, 1, webrtc::kVideoRotation_0)));
   AddInputFrame(input_frames_[0]);
   WaitOutputFrame();
   EXPECT_EQ(dummy_handle, output_frames_[0]->native_handle());
 
   input_frames_.push_back(CreateVideoFrame(2));
   AddInputFrame(input_frames_[1]);
   WaitOutputFrame();
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
 }
 
 TEST_F(ViECapturerTest, TestTextureFrameAfterI420Frame) {
   input_frames_.push_back(CreateVideoFrame(1));
   AddInputFrame(input_frames_[0]);
   WaitOutputFrame();
 
-  void* dummy_handle = &input_frames_;
-  input_frames_.push_back(new VideoFrame(dummy_handle, 1, 1, 2, 2,
-                                         webrtc::kVideoRotation_0,
-                                         rtc::Callback0<void>()));
+  test::FakeNativeHandle* dummy_handle = new test::FakeNativeHandle();
+  input_frames_.push_back(new VideoFrame(test::CreateFakeNativeHandleFrame(
+      dummy_handle, 1, 1, 2, 2, webrtc::kVideoRotation_0)));
   AddInputFrame(input_frames_[1]);
   WaitOutputFrame();
 
   EXPECT_TRUE(EqualFramesVector(input_frames_, output_frames_));
 }
 
 bool EqualFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
   if (frame1.native_handle() != NULL || frame2.native_handle() != NULL)
     return EqualTextureFrames(frame1, frame2);
   return EqualBufferFrames(frame1, frame2);
@@ skipping 43 matching lines @@
   uint8_t buffer[kSizeY];
   memset(buffer, data, kSizeY);
   frame->CreateFrame(
       buffer, buffer, buffer, width, height, width,
       width / 2, width / 2);
   frame->set_render_time_ms(data);
   return frame;
 }
 
 }  // namespace webrtc