Revert Make the new jitter buffer the default jitter buffer.

webrtc/modules/video_coding/frame_buffer2_unittest.cc

 /*
  *  Copyright (c) 2016 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/modules/video_coding/frame_buffer2.h"
 
 #include <algorithm>
 #include <cstring>
 #include <limits>
 #include <vector>
 
 #include "webrtc/base/platform_thread.h"
 #include "webrtc/base/random.h"
 #include "webrtc/modules/video_coding/frame_object.h"
 #include "webrtc/modules/video_coding/jitter_estimator.h"
 #include "webrtc/modules/video_coding/sequence_number_util.h"
 #include "webrtc/modules/video_coding/timing.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
-using testing::_;
-using testing::Return;
-
 namespace webrtc {
 namespace video_coding {
 
 class VCMTimingFake : public VCMTiming {
  public:
   explicit VCMTimingFake(Clock* clock) : VCMTiming(clock) {}
 
   int64_t RenderTimeMs(uint32_t frame_timestamp,
                        int64_t now_ms) const override {
     if (last_ms_ == -1) {
       last_ms_ = now_ms + kDelayMs;
       last_timestamp_ = frame_timestamp;
     }
 
     uint32_t diff = MinDiff(frame_timestamp, last_timestamp_);
     if (AheadOf(frame_timestamp, last_timestamp_))
       last_ms_ += diff / 90;
     else
       last_ms_ -= diff / 90;
 
     last_timestamp_ = frame_timestamp;
     return last_ms_;
   }
 
   uint32_t MaxWaitingTime(int64_t render_time_ms,
                           int64_t now_ms) const override {
     return std::max<int>(0, render_time_ms - now_ms - kDecodeTime);
   }
 
-  bool GetTimings(int* decode_ms,
-                  int* max_decode_ms,
-                  int* current_delay_ms,
-                  int* target_delay_ms,
-                  int* jitter_buffer_ms,
-                  int* min_playout_delay_ms,
-                  int* render_delay_ms) const override {
-    return true;
-  }
-
  private:
   static constexpr int kDelayMs = 50;
   static constexpr int kDecodeTime = kDelayMs / 2;
   mutable uint32_t last_timestamp_ = 0;
   mutable int64_t last_ms_ = -1;
 };
 
 class VCMJitterEstimatorMock : public VCMJitterEstimator {
  public:
   explicit VCMJitterEstimatorMock(Clock* clock) : VCMJitterEstimator(clock) {}
 
   MOCK_METHOD1(UpdateRtt, void(int64_t rttMs));
   MOCK_METHOD3(UpdateEstimate,
                void(int64_t frameDelayMs,
                     uint32_t frameSizeBytes,
                     bool incompleteFrame));
   MOCK_METHOD1(GetJitterEstimate, int(double rttMultiplier));
 };
 
 class FrameObjectFake : public FrameObject {
  public:
   bool GetBitstream(uint8_t* destination) const override { return true; }
 
   uint32_t Timestamp() const override { return timestamp; }
 
   int64_t ReceivedTime() const override { return 0; }
 
   int64_t RenderTime() const override { return _renderTimeMs; }
-
-  // In EncodedImage |_length| is used to descibe its size and |_size| to
-  // describe its capacity.
-  void SetSize(int size) { _length = size; }
-};
-
-class VCMReceiveStatisticsCallbackMock : public VCMReceiveStatisticsCallback {
- public:
-  MOCK_METHOD2(OnReceiveRatesUpdated,
-               void(uint32_t bitRate, uint32_t frameRate));
-  MOCK_METHOD2(OnCompleteFrame, void(bool is_keyframe, size_t size_bytes));
-  MOCK_METHOD1(OnDiscardedPacketsUpdated, void(int discarded_packets));
-  MOCK_METHOD1(OnFrameCountsUpdated, void(const FrameCounts& frame_counts));
-  MOCK_METHOD7(OnFrameBufferTimingsUpdated,
-               void(int decode_ms,
-                    int max_decode_ms,
-                    int current_delay_ms,
-                    int target_delay_ms,
-                    int jitter_buffer_ms,
-                    int min_playout_delay_ms,
-                    int render_delay_ms));
 };
 
 class TestFrameBuffer2 : public ::testing::Test {
  protected:
   static constexpr int kMaxReferences = 5;
   static constexpr int kFps1 = 1000;
   static constexpr int kFps10 = kFps1 / 10;
   static constexpr int kFps20 = kFps1 / 20;
 
   TestFrameBuffer2()
       : clock_(0),
         timing_(&clock_),
         jitter_estimator_(&clock_),
-        buffer_(&clock_, &jitter_estimator_, &timing_, &stats_callback_),
+        buffer_(&clock_, &jitter_estimator_, &timing_),
         rand_(0x34678213),
         tear_down_(false),
         extract_thread_(&ExtractLoop, this, "Extract Thread"),
         trigger_extract_event_(false, false),
         crit_acquired_event_(false, false) {}
 
   void SetUp() override { extract_thread_.Start(); }
 
   void TearDown() override {
     tear_down_ = true;
@@ skipping 74 matching lines @@
   }
 
   uint32_t Rand() { return rand_.Rand<uint32_t>(); }
 
   SimulatedClock clock_;
   VCMTimingFake timing_;
   ::testing::NiceMock<VCMJitterEstimatorMock> jitter_estimator_;
   FrameBuffer buffer_;
   std::vector<std::unique_ptr<FrameObject>> frames_;
   Random rand_;
-  ::testing::NiceMock<VCMReceiveStatisticsCallbackMock> stats_callback_;
 
   int64_t max_wait_time_;
   bool tear_down_;
   rtc::PlatformThread extract_thread_;
   rtc::Event trigger_extract_event_;
   rtc::Event crit_acquired_event_;
   rtc::CriticalSection crit_;
 };
 
 // Following tests are timing dependent. Either the timeouts have to
@@ skipping 227 matching lines @@
   CheckFrame(0, pid, 0);
 
   // Jump back in pid but increase ts.
   EXPECT_EQ(pid - 1, InsertFrame(pid - 1, 0, ts + 2, false));
   ExtractFrame();
   ExtractFrame();
   CheckFrame(1, pid - 1, 0);
   CheckNoFrame(2);
 }
 
-TEST_F(TestFrameBuffer2, StatsCallback) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-  const int kFrameSize = 5000;
-
-  EXPECT_CALL(stats_callback_, OnCompleteFrame(true, kFrameSize));
-  EXPECT_CALL(stats_callback_,
-              OnFrameBufferTimingsUpdated(_, _, _, _, _, _, _));
-
-  {
-    std::unique_ptr<FrameObjectFake> frame(new FrameObjectFake());
-    frame->SetSize(kFrameSize);
-    frame->picture_id = pid;
-    frame->spatial_layer = 0;
-    frame->timestamp = ts;
-    frame->num_references = 0;
-    frame->inter_layer_predicted = false;
-
-    EXPECT_EQ(buffer_.InsertFrame(std::move(frame)), pid);
-  }
-
-  ExtractFrame();
-  CheckFrame(0, pid, 0);
-}
-
 }  // namespace video_coding
 }  // namespace webrtc