Revert of FrameBuffer for the new jitter buffer.

webrtc/modules/video_coding/frame_buffer2_unittest.cc

Index: webrtc/modules/video_coding/frame_buffer2_unittest.cc
diff --git a/webrtc/modules/video_coding/frame_buffer2_unittest.cc b/webrtc/modules/video_coding/frame_buffer2_unittest.cc
deleted file mode 100644
index 67706ce05819b51ec8fc6befeea2ac374c23dd9f..0000000000000000000000000000000000000000
--- a/webrtc/modules/video_coding/frame_buffer2_unittest.cc
+++ /dev/null
@@ -1,329 +0,0 @@
-/*
- *  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 "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#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"
-
-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);
-  }
-
- 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));
-};
-
-class FrameObjectMock : public FrameObject {
- public:
-  MOCK_CONST_METHOD1(GetBitstream, bool(uint8_t* destination));
-};
-
-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_),
-        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;
-    trigger_extract_event_.Set();
-    extract_thread_.Stop();
-  }
-
-  template <typename... T>
-  void InsertFrame(uint16_t picture_id,
-                   uint8_t spatial_layer,
-                   int64_t ts_ms,
-                   bool inter_layer_predicted,
-                   T... refs) {
-    static_assert(sizeof...(refs) <= kMaxReferences,
-                  "To many references specified for FrameObject.");
-    std::array<uint16_t, sizeof...(refs)> references = {{refs...}};
-
-    std::unique_ptr<FrameObjectMock> frame(new FrameObjectMock());
-    frame->picture_id = picture_id;
-    frame->spatial_layer = spatial_layer;
-    frame->timestamp = ts_ms * 90;
-    frame->num_references = references.size();
-    frame->inter_layer_predicted = inter_layer_predicted;
-    for (size_t r = 0; r < references.size(); ++r)
-      frame->references[r] = references[r];
-
-    buffer_.InsertFrame(std::move(frame));
-  }
-
-  void ExtractFrame(int64_t max_wait_time = 0) {
-    crit_.Enter();
-    if (max_wait_time == 0) {
-      frames_.emplace_back(buffer_.NextFrame(0));
-      crit_.Leave();
-    } else {
-      max_wait_time_ = max_wait_time;
-      trigger_extract_event_.Set();
-      crit_.Leave();
-      // Make sure |crit_| is aquired by |extract_thread_| before returning.
-      crit_acquired_event_.Wait(rtc::Event::kForever);
-    }
-  }
-
-  void CheckFrame(size_t index, int picture_id, int spatial_layer) {
-    rtc::CritScope lock(&crit_);
-    ASSERT_LT(index, frames_.size());
-    ASSERT_TRUE(frames_[index]);
-    ASSERT_EQ(picture_id, frames_[index]->picture_id);
-    ASSERT_EQ(spatial_layer, frames_[index]->spatial_layer);
-  }
-
-  void CheckNoFrame(size_t index) {
-    rtc::CritScope lock(&crit_);
-    ASSERT_LT(index, frames_.size());
-    ASSERT_FALSE(frames_[index]);
-  }
-
-  static bool ExtractLoop(void* obj) {
-    TestFrameBuffer2* tfb = static_cast<TestFrameBuffer2*>(obj);
-    while (true) {
-      tfb->trigger_extract_event_.Wait(rtc::Event::kForever);
-      {
-        rtc::CritScope lock(&tfb->crit_);
-        tfb->crit_acquired_event_.Set();
-        if (tfb->tear_down_)
-          return false;
-
-        tfb->frames_.emplace_back(tfb->buffer_.NextFrame(tfb->max_wait_time_));
-      }
-    }
-  }
-
-  uint32_t Rand() { return rand_.Rand<uint32_t>(); }
-
-  SimulatedClock clock_;
-  VCMTimingFake timing_;
-  VCMJitterEstimatorMock jitter_estimator_;
-  FrameBuffer buffer_;
-  std::vector<std::unique_ptr<FrameObject>> frames_;
-  Random rand_;
-
-  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_;
-};
-
-TEST_F(TestFrameBuffer2, ExtractFromEmptyBuffer) {
-  ExtractFrame();
-  CheckNoFrame(0);
-}
-
-TEST_F(TestFrameBuffer2, WaitForFrame) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  ExtractFrame(20);
-  InsertFrame(pid, 0, ts, false);
-  CheckFrame(0, pid, 0);
-}
-
-TEST_F(TestFrameBuffer2, OneSuperFrame) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  ExtractFrame(20);
-  InsertFrame(pid, 1, ts, true);
-  InsertFrame(pid, 0, ts, false);
-  ExtractFrame();
-
-  CheckFrame(0, pid, 0);
-  CheckFrame(1, pid, 1);
-}
-
-TEST_F(TestFrameBuffer2, OneLayerStream) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  InsertFrame(pid, 0, ts, false);
-  ExtractFrame();
-  CheckFrame(0, pid, 0);
-  for (int i = 1; i < 10; ++i) {
-    InsertFrame(pid + i, 0, ts + i * kFps10, false, pid + i - 1);
-    ExtractFrame();
-    clock_.AdvanceTimeMilliseconds(kFps10);
-    CheckFrame(i, pid + i, 0);
-  }
-}
-
-TEST_F(TestFrameBuffer2, OneLayerStreamReordered) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  InsertFrame(pid, 0, ts, false);
-  ExtractFrame();
-  CheckFrame(0, pid, 0);
-  for (int i = 1; i < 10; i += 2) {
-    ExtractFrame(15);
-    InsertFrame(pid + i + 1, 0, ts + (i + 1) * kFps10, false, pid + i);
-    clock_.AdvanceTimeMilliseconds(kFps10);
-    InsertFrame(pid + i, 0, ts + i * kFps10, false, pid + i - 1);
-    clock_.AdvanceTimeMilliseconds(kFps10);
-    ExtractFrame();
-    CheckFrame(i, pid + i, 0);
-    CheckFrame(i + 1, pid + i + 1, 0);
-  }
-}
-
-TEST_F(TestFrameBuffer2, DropTemporalLayerSlowDecoder) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  InsertFrame(pid, 0, ts, false);
-  InsertFrame(pid + 1, 0, ts + kFps20, false);
-  for (int i = 2; i < 10; i += 2) {
-    uint32_t ts_tl0 = ts + i / 2 * kFps10;
-    InsertFrame(pid + i, 0, ts_tl0, false, pid + i - 2);
-    InsertFrame(pid + i + 1, 0, ts_tl0 + kFps20, false, pid + i, pid + i - 1);
-  }
-
-  for (int i = 0; i < 10; ++i) {
-    ExtractFrame();
-    clock_.AdvanceTimeMilliseconds(60);
-  }
-
-  CheckFrame(0, pid, 0);
-  CheckFrame(1, pid + 1, 0);
-  CheckFrame(2, pid + 2, 0);
-  CheckFrame(3, pid + 4, 0);
-  CheckFrame(4, pid + 6, 0);
-  CheckFrame(5, pid + 8, 0);
-  CheckNoFrame(6);
-  CheckNoFrame(7);
-  CheckNoFrame(8);
-  CheckNoFrame(9);
-}
-
-TEST_F(TestFrameBuffer2, DropSpatialLayerSlowDecoder) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  InsertFrame(pid, 0, ts, false);
-  InsertFrame(pid, 1, ts, false);
-  for (int i = 1; i < 6; ++i) {
-    uint32_t ts_tl0 = ts + i * kFps10;
-    InsertFrame(pid + i, 0, ts_tl0, false, pid + i - 1);
-    InsertFrame(pid + i, 1, ts_tl0, false, pid + i - 1);
-  }
-
-  ExtractFrame();
-  ExtractFrame();
-  clock_.AdvanceTimeMilliseconds(55);
-  for (int i = 2; i < 12; ++i) {
-    ExtractFrame();
-    clock_.AdvanceTimeMilliseconds(55);
-  }
-
-  CheckFrame(0, pid, 0);
-  CheckFrame(1, pid, 1);
-  CheckFrame(2, pid + 1, 0);
-  CheckFrame(3, pid + 1, 1);
-  CheckFrame(4, pid + 2, 0);
-  CheckFrame(5, pid + 2, 1);
-  CheckFrame(6, pid + 3, 0);
-  CheckFrame(7, pid + 4, 0);
-  CheckFrame(8, pid + 5, 0);
-  CheckNoFrame(9);
-  CheckNoFrame(10);
-  CheckNoFrame(11);
-}
-
-TEST_F(TestFrameBuffer2, InsertLateFrame) {
-  uint16_t pid = Rand();
-  uint32_t ts = Rand();
-
-  InsertFrame(pid, 0, ts, false);
-  ExtractFrame();
-  InsertFrame(pid + 2, 0, ts, false);
-  ExtractFrame();
-  InsertFrame(pid + 1, 0, ts, false, pid);
-  ExtractFrame();
-
-  CheckFrame(0, pid, 0);
-  CheckFrame(1, pid + 2, 0);
-  CheckNoFrame(2);
-}
-
-}  // namespace video_coding
-}  // namespace webrtc