Revert of Delete VideoFrameFactory, CapturedFrame, and related code.

webrtc/media/base/videoadapter_unittest.cc

 /*
  *  Copyright (c) 2010 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 13 matching lines @@
 namespace cricket {
 
 class VideoAdapterTest : public testing::Test {
  public:
   virtual void SetUp() {
     capturer_.reset(new FakeVideoCapturer);
     capture_format_ = capturer_->GetSupportedFormats()->at(0);
     capture_format_.interval = VideoFormat::FpsToInterval(30);
 
     listener_.reset(new VideoCapturerListener(&adapter_));
-    capturer_->AddOrUpdateSink(listener_.get(), rtc::VideoSinkWants());
+    capturer_->SignalFrameCaptured.connect(
+        listener_.get(), &VideoCapturerListener::OnFrameCaptured);
   }
 
   virtual void TearDown() {
     // Explicitly disconnect the VideoCapturer before to avoid data races
     // (frames delivered to VideoCapturerListener while it's being destructed).
-    capturer_->RemoveSink(listener_.get());
+    capturer_->SignalFrameCaptured.disconnect_all();
   }
 
  protected:
-  class VideoCapturerListener
-      : public rtc::VideoSinkInterface<cricket::VideoFrame> {
+  class VideoCapturerListener: public sigslot::has_slots<> {
    public:
     struct Stats {
       int captured_frames;
       int dropped_frames;
       bool last_adapt_was_no_op;
 
       int cropped_width;
       int cropped_height;
       int out_width;
       int out_height;
     };
 
     explicit VideoCapturerListener(VideoAdapter* adapter)
         : video_adapter_(adapter),
           captured_frames_(0),
           dropped_frames_(0),
           last_adapt_was_no_op_(false) {
     }
 
-    void OnFrame(const cricket::VideoFrame& frame) {
+    void OnFrameCaptured(VideoCapturer* capturer,
+                         const CapturedFrame* captured_frame) {
       rtc::CritScope lock(&crit_);
-      const int in_width = frame.width();
-      const int in_height = frame.height();
+      const int in_width = captured_frame->width;
+      const int in_height = abs(captured_frame->height);
       int cropped_width;
       int cropped_height;
       int out_width;
       int out_height;
-      if (video_adapter_->AdaptFrameResolution(
-              in_width, in_height,
-              frame.timestamp_us() * rtc::kNumNanosecsPerMicrosec,
-              &cropped_width, &cropped_height, &out_width, &out_height)) {
+      if (video_adapter_->AdaptFrameResolution(in_width, in_height,
+                                               captured_frame->time_stamp,
+                                               &cropped_width, &cropped_height,
+                                               &out_width, &out_height)) {
         cropped_width_ = cropped_width;
         cropped_height_ = cropped_height;
         out_width_ = out_width;
         out_height_ = out_height;
         last_adapt_was_no_op_ =
             (in_width == cropped_width && in_height == cropped_height &&
              in_width == out_width && in_height == out_height);
       } else {
         ++dropped_frames_;
       }
@@ skipping 88 matching lines @@
   EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
 
   // Capture 10 frames and verify that every other frame is dropped. The first
   // frame should not be dropped.
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 1);
   EXPECT_EQ(0, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 2);
-  EXPECT_EQ(1, listener_->GetStats().dropped_frames);
+  EXPECT_EQ(0, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 3);
   EXPECT_EQ(1, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 4);
-  EXPECT_EQ(2, listener_->GetStats().dropped_frames);
+  EXPECT_EQ(1, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 5);
   EXPECT_EQ(2, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 6);
-  EXPECT_EQ(3, listener_->GetStats().dropped_frames);
+  EXPECT_EQ(2, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 7);
   EXPECT_EQ(3, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 8);
-  EXPECT_EQ(4, listener_->GetStats().dropped_frames);
+  EXPECT_EQ(3, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 9);
   EXPECT_EQ(4, listener_->GetStats().dropped_frames);
 
   capturer_->CaptureFrame();
   EXPECT_GE(listener_->GetStats().captured_frames, 10);
-  EXPECT_EQ(5, listener_->GetStats().dropped_frames);
+  EXPECT_EQ(4, listener_->GetStats().dropped_frames);
 }
 
 // Adapt the frame rate to be two thirds of the capture rate at the beginning.
 // Expect the number of dropped frames to be one thirds of the number the
 // captured frames.
 TEST_F(VideoAdapterTest, AdaptFramerateToTwoThirds) {
   VideoFormat request_format = capture_format_;
   request_format.interval = request_format.interval * 3 / 2;
   adapter_.OnOutputFormatRequest(request_format);
   EXPECT_EQ(CS_RUNNING, capturer_->Start(capture_format_));
@@ skipping 717 matching lines @@
 
   // Instead of getting the exact aspect ratio with cropped resolution 640x360,
   // the resolution should be adjusted to get a perfect scale factor instead.
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(368, cropped_height_);
   EXPECT_EQ(120, out_width_);
   EXPECT_EQ(69, out_height_);
 }
 
 }  // namespace cricket