Added various timestamps to FrameObject.

webrtc/modules/video_coding/video_packet_buffer_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 <cstring>
 #include <limits>
 #include <map>
 #include <set>
 #include <utility>
 
+#include "testing/gtest/include/gtest/gtest.h"
+#include "webrtc/base/random.h"
 #include "webrtc/modules/video_coding/frame_object.h"
 #include "webrtc/modules/video_coding/packet_buffer.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/base/random.h"
+#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 namespace video_coding {
 
 class TestPacketBuffer : public ::testing::Test,
                          public OnCompleteFrameCallback {
  protected:
   TestPacketBuffer()
       : rand_(0x8739211),
-        packet_buffer_(new PacketBuffer(kStartSize, kMaxSize, this)),
+        clock_(new SimulatedClock(0)),
+        packet_buffer_(new PacketBuffer(clock_.get(),
+                       kStartSize,
+                       kMaxSize,
+                       this)),
         frames_from_callback_(FrameComp()),
         dummy_data_(new uint8_t[kDummyDataSize]()) {}
 
   uint16_t Rand() { return rand_.Rand(std::numeric_limits<uint16_t>::max()); }
 
   void OnCompleteFrame(std::unique_ptr<FrameObject> frame) override {
     uint16_t pid = frame->picture_id;
     uint16_t sidx = frame->spatial_layer;
     auto frame_it = frames_from_callback_.find(std::make_pair(pid, sidx));
     if (frame_it != frames_from_callback_.end()) {
@@ skipping 199 matching lines @@
     RefsToSet(m, refs...);
   }
 
   void RefsToSet(std::set<uint16_t>* m) const {}
 
   const int kStartSize = 16;
   const int kMaxSize = 64;
   const int kDummyDataSize = 4;
 
   Random rand_;
+  std::unique_ptr<Clock> clock_;
   std::unique_ptr<PacketBuffer> packet_buffer_;
   struct FrameComp {
     bool operator()(const std::pair<uint16_t, uint8_t> f1,
                     const std::pair<uint16_t, uint8_t> f2) const {
                       if (f1.first == f2.first)
                         return f1.second < f2.second;
                       return f1.first < f2.first;
                     }
   };
   std::map<std::pair<uint16_t, uint8_t>,
@@ skipping 661 matching lines @@
   CheckReferencesVp8(pid);
   CheckReferencesVp8(pid + 1, pid);
   CheckReferencesVp8(pid + 2, pid);
   CheckReferencesVp8(pid + 4, pid + 2);
   CheckReferencesVp8(pid + 5, pid + 4);
   CheckReferencesVp8(pid + 6, pid + 4);
   CheckReferencesVp8(pid + 7, pid + 6, pid + 5);
 }
 
 TEST_F(TestPacketBuffer, Vp8InsertLargeFrames) {
-  packet_buffer_.reset(new PacketBuffer(1 << 3, 1 << 12, this));
+  packet_buffer_.reset(new PacketBuffer(clock_.get(), 1 << 3, 1 << 12, this));
   uint16_t pid = Rand();
   uint16_t seq_num = Rand();
 
   const uint16_t packets_per_frame = 1000;
   uint16_t current = seq_num;
   uint16_t end = current + packets_per_frame;
 
   //        seq_num  , keyf, frst, lst, sync, pid, tid, tl0
   InsertVp8(current++, kT  , kT  , kF , kF  , pid, 0  , 0);
   while (current != end)
@@ skipping 576 matching lines @@
   CheckReferencesVp9(pid + 5, 1, pid + 4);
   CheckReferencesVp9(pid + 6, 0, pid + 4);
   CheckReferencesVp9(pid + 6, 1, pid + 5);
   CheckReferencesVp9(pid + 7, 1, pid + 6);
   CheckReferencesVp9(pid + 8, 0, pid + 6);
   CheckReferencesVp9(pid + 8, 1, pid + 7);
 }
 
 }  // namespace video_coding
 }  // namespace webrtc