Delete method webrtc::VideoFrame::native_handle.

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 14 matching lines @@
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_format_vp9.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/system_wrappers/include/sleep.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/frame_utils.h"
 #include "webrtc/test/null_transport.h"
 #include "webrtc/test/testsupport/perf_test.h"
 #include "webrtc/video/send_statistics_proxy.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 VideoSendStreamTest : public test::CallTest {
  protected:
   void TestNackRetransmission(uint32_t retransmit_ssrc,
                               uint8_t retransmit_payload_type);
   void TestPacketFragmentationSize(VideoFormat format, bool with_fec);
 
@@ skipping 1177 matching lines @@
   }
   video_send_stream_->Stop();
 
   // Test if the input and output frames are the same. render_time_ms and
   // timestamp are not compared because capturer sets those values.
   ExpectEqualFramesVector(input_frames, observer.output_frames());
 
   DestroyStreams();
 }
 
-void ExpectEqualFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
-  if (frame1.native_handle() || frame2.native_handle())
-    ExpectEqualTextureFrames(frame1, frame2);
-  else
-    ExpectEqualBufferFrames(frame1, frame2);
-}
-
-void ExpectEqualTextureFrames(const VideoFrame& frame1,
-                              const VideoFrame& frame2) {
-  EXPECT_EQ(frame1.native_handle(), frame2.native_handle());
-  EXPECT_EQ(frame1.width(), frame2.width());
-  EXPECT_EQ(frame1.height(), frame2.height());
-}
-
-void ExpectEqualBufferFrames(const VideoFrame& frame1,
-                             const VideoFrame& frame2) {
-  EXPECT_EQ(frame1.width(), frame2.width());
-  EXPECT_EQ(frame1.height(), frame2.height());
-  EXPECT_EQ(frame1.stride(kYPlane), frame2.stride(kYPlane));
-  EXPECT_EQ(frame1.stride(kUPlane), frame2.stride(kUPlane));
-  EXPECT_EQ(frame1.stride(kVPlane), frame2.stride(kVPlane));
-  ASSERT_EQ(frame1.allocated_size(kYPlane), frame2.allocated_size(kYPlane));
-  EXPECT_EQ(0,
-            memcmp(frame1.buffer(kYPlane),
-                   frame2.buffer(kYPlane),
-                   frame1.allocated_size(kYPlane)));
-  ASSERT_EQ(frame1.allocated_size(kUPlane), frame2.allocated_size(kUPlane));
-  EXPECT_EQ(0,
-            memcmp(frame1.buffer(kUPlane),
-                   frame2.buffer(kUPlane),
-                   frame1.allocated_size(kUPlane)));
-  ASSERT_EQ(frame1.allocated_size(kVPlane), frame2.allocated_size(kVPlane));
-  EXPECT_EQ(0,
-            memcmp(frame1.buffer(kVPlane),
-                   frame2.buffer(kVPlane),
-                   frame1.allocated_size(kVPlane)));
-}
-
 void ExpectEqualFramesVector(const std::vector<VideoFrame>& frames1,
                              const std::vector<VideoFrame>& frames2) {
   EXPECT_EQ(frames1.size(), frames2.size());
   for (size_t i = 0; i < std::min(frames1.size(), frames2.size()); ++i)
-    ExpectEqualFrames(frames1[i], frames2[i]);
+    // Compare frame buffers, since we don't care about differing timestamps.
+    EXPECT_TRUE(test::FrameBufsEqual(frames1[i].video_frame_buffer(),
+                                     frames2[i].video_frame_buffer()));
 }
 
 VideoFrame CreateVideoFrame(int width, int height, uint8_t data) {
   const int kSizeY = width * height * 2;
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[kSizeY]);
   memset(buffer.get(), data, kSizeY);
   VideoFrame frame;
   frame.CreateFrame(buffer.get(), buffer.get(), buffer.get(), width, height,
                     width, width / 2, width / 2, kVideoRotation_0);
   frame.set_timestamp(data);
@@ skipping 1012 matching lines @@
         observation_complete_.Set();
       }
     }
   } test;
 
   RunBaseTest(&test);
 }
 #endif
 
 }  // namespace webrtc