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

webrtc/common_video/i420_video_frame_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.
  */
 
 #include "webrtc/video_frame.h"
 
 #include <math.h>
 #include <string.h>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/scoped_ptr.h"
+#include "webrtc/test/fake_texture_frame.h"
 
 namespace webrtc {
 
-class NativeHandleImpl {
- public:
-  NativeHandleImpl() : no_longer_needed_(false) {}
-  virtual ~NativeHandleImpl() {}
-  bool no_longer_needed() const { return no_longer_needed_; }
-  void SetNoLongerNeeded() { no_longer_needed_ = true; }
-
- private:
-  bool no_longer_needed_;
-};
-
 bool EqualPlane(const uint8_t* data1,
                 const uint8_t* data2,
                 int stride,
                 int width,
                 int height);
 bool EqualFrames(const VideoFrame& frame1, const VideoFrame& frame2);
-bool EqualTextureFrames(const VideoFrame& frame1, const VideoFrame& frame2);
 int ExpectedSize(int plane_stride, int image_height, PlaneType type);
 
 TEST(TestVideoFrame, InitialValues) {
   VideoFrame frame;
   EXPECT_TRUE(frame.IsZeroSize());
   EXPECT_EQ(kVideoRotation_0, frame.rotation());
 }
 
 TEST(TestVideoFrame, CopiesInitialFrameWithoutCrashing) {
   VideoFrame frame;
@@ skipping 197 matching lines @@
   const uint8_t* v = frame1.buffer(kVPlane);
   // Make a shallow copy of |frame1|.
   VideoFrame frame2(frame1.video_frame_buffer(), 0, 0, kVideoRotation_0);
   frame1.CreateEmptyFrame(640, 320, 640, 320, 320);
   EXPECT_NE(y, frame1.buffer(kYPlane));
   EXPECT_NE(u, frame1.buffer(kUPlane));
   EXPECT_NE(v, frame1.buffer(kVPlane));
 }
 
 TEST(TestVideoFrame, TextureInitialValues) {
-  NativeHandleImpl handle;
-  VideoFrame frame(&handle, 640, 480, 100, 10, webrtc::kVideoRotation_0,
-                   rtc::Callback0<void>());
+  test::FakeNativeHandle* handle = new test::FakeNativeHandle();
+  VideoFrame frame = test::CreateFakeNativeHandleFrame(
+      handle, 640, 480, 100, 10, webrtc::kVideoRotation_0);
   EXPECT_EQ(640, frame.width());
   EXPECT_EQ(480, frame.height());
   EXPECT_EQ(100u, frame.timestamp());
   EXPECT_EQ(10, frame.render_time_ms());
-  EXPECT_EQ(&handle, frame.native_handle());
+  EXPECT_EQ(handle, frame.native_handle());
 
   frame.set_timestamp(200);
   EXPECT_EQ(200u, frame.timestamp());
   frame.set_render_time_ms(20);
   EXPECT_EQ(20, frame.render_time_ms());
 }
 
-TEST(TestVideoFrame, NoLongerNeeded) {
-  NativeHandleImpl handle;
-  ASSERT_FALSE(handle.no_longer_needed());
-  VideoFrame* frame =
-      new VideoFrame(&handle, 640, 480, 100, 200, webrtc::kVideoRotation_0,
-                     rtc::Bind(&NativeHandleImpl::SetNoLongerNeeded, &handle));
-  EXPECT_FALSE(handle.no_longer_needed());
-  delete frame;
-  EXPECT_TRUE(handle.no_longer_needed());
-}
-
 bool EqualPlane(const uint8_t* data1,
                 const uint8_t* data2,
                 int stride,
                 int width,
                 int height) {
   for (int y = 0; y < height; ++y) {
     if (memcmp(data1, data2, width) != 0)
       return false;
     data1 += stride;
     data2 += stride;
@@ skipping 15 matching lines @@
   const int half_width = (frame1.width() + 1) / 2;
   const int half_height = (frame1.height() + 1) / 2;
   return EqualPlane(frame1.buffer(kYPlane), frame2.buffer(kYPlane),
                     frame1.stride(kYPlane), frame1.width(), frame1.height()) &&
          EqualPlane(frame1.buffer(kUPlane), frame2.buffer(kUPlane),
                     frame1.stride(kUPlane), half_width, half_height) &&
          EqualPlane(frame1.buffer(kVPlane), frame2.buffer(kVPlane),
                     frame1.stride(kVPlane), half_width, half_height);
 }
 
-bool EqualTextureFrames(const VideoFrame& frame1, const VideoFrame& frame2) {
-  return ((frame1.native_handle() == frame2.native_handle()) &&
-          (frame1.width() == frame2.width()) &&
-          (frame1.height() == frame2.height()) &&
-          (frame1.timestamp() == frame2.timestamp()) &&
-          (frame1.render_time_ms() == frame2.render_time_ms()));
-}
-
 int ExpectedSize(int plane_stride, int image_height, PlaneType type) {
   if (type == kYPlane) {
     return (plane_stride * image_height);
   } else {
     int half_height = (image_height + 1) / 2;
     return (plane_stride * half_height);
   }
 }
 
 }  // namespace webrtc