Reland of 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_),
+        buffer_(&clock_, &jitter_estimator_, &timing_, &stats_callback_),
         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 226 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