RTCStatsCollector and RTCPeerConnectionStats added

webrtc/stats/rtcstatscollector.h

Index: webrtc/stats/rtcstatscollector.h
diff --git a/webrtc/stats/rtcstatscollector.h b/webrtc/stats/rtcstatscollector.h
new file mode 100644
index 0000000000000000000000000000000000000000..666bbdc33ff72f14520c020a21c2314b9121c06e
--- /dev/null
+++ b/webrtc/stats/rtcstatscollector.h
@@ -0,0 +1,59 @@
+/*
+ *  Copyright 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.
+ */
+
+#ifndef WEBRTC_STATS_RTCSTATSCOLLECTOR_H_
+#define WEBRTC_STATS_RTCSTATSCOLLECTOR_H_
+
+#include <memory>
+
+#include "webrtc/api/peerconnection.h"
+#include "webrtc/api/rtcstats_objects.h"
+#include "webrtc/api/rtcstatsreport.h"
+#include "webrtc/base/refcount.h"
+#include "webrtc/base/scoped_ref_ptr.h"
+#include "webrtc/base/timing.h"
+
+namespace webrtc {
+
+// All calls to the collector and gathering of stats is performed on the
+// signaling thread. A stats report is cached for |cache_lifetime_| ms.
+class RTCStatsCollector {
+ public:
+  RTCStatsCollector(
+      PeerConnection* pc,
+      double cache_lifetime = 50.0,

[hta-webrtc, 2016/08/24 13:02:16]

What's the unit of this lifetime?
It used to be 50 milliseconds, but all other doubles are in seconds (I think).

[hbos, 2016/08/24 14:28:00]

Changed to seconds and added a comment for the variable.

+      std::unique_ptr<rtc::Timing> timing = std::unique_ptr<rtc::Timing>(
+          new rtc::Timing()));

[hta-webrtc, 2016/08/24 13:02:16]

Checking: Do default arguments to constructors get executed once (like in
Python) or every time we invoke the constructor?
(I assume it won't be executed when the argument is filled in.)

If the latter, will there be a new rtc::Timing() object created for every
instance of RTCStatsCollector? That seems wasteful.

[hbos, 2016/08/24 14:28:00]

There's one Timing object constructed per collector. It contains no data, only
methods, so it's not that wasteful. We'll only have one collector per peer
connection.

+
+  // Gets a recent stats report. If there is a report cached that is still fresh
+  // it is returned, otherwise new stats are gathered and returned. A report is
+  // considered fresh for |cache_lifetime_| ms. const RTCStatsReports are safe
+  // to use across multiple threads and may be destructed on any thread.
+  rtc::scoped_refptr<const RTCStatsReport> GetStatsReport();
+  // Clears the cache's reference to the most recent stats report. Subsequently
+  // calling |GetStatsReport| guarantees fresh stats.
+  void ClearCachedStatsReport();
+
+ private:
+  bool IsSignalingThread() const;
+  double GetTimeNowMs() const;
+
+  std::unique_ptr<RTCPeerConnectionStats> ProducePeerConnectionStats() const;
+
+  PeerConnection* const pc_;
+  mutable std::unique_ptr<rtc::Timing> timing_;
+  double cache_timestamp_;
+  double cache_lifetime_;
+  rtc::scoped_refptr<const RTCStatsReport> cached_report_;
+};
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_STATS_RTCSTATSCOLLECTOR_H_