74e1a4f96a
New file structure and targets: rtc_stats_api webrtc/api/stats/rtcstats.h webrtc/api/stats/rtcstats_objects.h webrtc/api/stats/rtcstatsreport.h rtc_stats (dep on rtc_stats_api) webrtc/stats/rtcstats.cc webrtc/stats/rtcstats_objects.cc webrtc/stats/rtcstatsreport.cc libjingle_peerconnection (dep on rtc_stats) webrtc/api/rtcstatscollector.cc webrtc/api/rtcstatscollector.h Placing rtc_stats_api headers in this separate target instead of libjingle_peerconnection avoids a circular dependency libjingle_peerconnection -> rtc_stats -> libjingle_peerconnection Code changes: PeerConnectionInterface::GetStats(RTCStatsCollectorCallback*) added for the new stats collection API. Implemented by PeerConnection. BUG=chromium:627816 Review-Url: https://codereview.webrtc.org/2331373004 Cr-Commit-Position: refs/heads/master@{#14246}
98 lines
3.6 KiB
C++
98 lines
3.6 KiB
C++
/*
|
|
* 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_API_RTCSTATSCOLLECTOR_H_
|
|
#define WEBRTC_API_RTCSTATSCOLLECTOR_H_
|
|
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "webrtc/api/stats/rtcstats_objects.h"
|
|
#include "webrtc/api/stats/rtcstatsreport.h"
|
|
#include "webrtc/base/asyncinvoker.h"
|
|
#include "webrtc/base/refcount.h"
|
|
#include "webrtc/base/scoped_ref_ptr.h"
|
|
#include "webrtc/base/timeutils.h"
|
|
|
|
namespace webrtc {
|
|
|
|
class PeerConnection;
|
|
|
|
class RTCStatsCollectorCallback : public virtual rtc::RefCountInterface {
|
|
public:
|
|
virtual ~RTCStatsCollectorCallback() {}
|
|
|
|
virtual void OnStatsDelivered(
|
|
const rtc::scoped_refptr<const RTCStatsReport>& report) = 0;
|
|
};
|
|
|
|
// All public methods of the collector are to be called on the signaling thread.
|
|
// Stats are gathered on the signaling, worker and network threads
|
|
// asynchronously. The callback is invoked on the signaling thread. Resulting
|
|
// reports are cached for |cache_lifetime_| ms.
|
|
class RTCStatsCollector : public virtual rtc::RefCountInterface {
|
|
public:
|
|
static rtc::scoped_refptr<RTCStatsCollector> Create(
|
|
PeerConnection* pc,
|
|
int64_t cache_lifetime_us = 50 * rtc::kNumMicrosecsPerMillisec);
|
|
|
|
// 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.
|
|
void GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback> callback);
|
|
// Clears the cache's reference to the most recent stats report. Subsequently
|
|
// calling |GetStatsReport| guarantees fresh stats.
|
|
void ClearCachedStatsReport();
|
|
|
|
protected:
|
|
RTCStatsCollector(PeerConnection* pc, int64_t cache_lifetime_us);
|
|
|
|
// Stats gathering on a particular thread. Calls |AddPartialResults| before
|
|
// returning. Virtual for the sake of testing.
|
|
virtual void ProducePartialResultsOnSignalingThread(int64_t timestamp_us);
|
|
virtual void ProducePartialResultsOnWorkerThread(int64_t timestamp_us);
|
|
virtual void ProducePartialResultsOnNetworkThread(int64_t timestamp_us);
|
|
|
|
// Can be called on any thread.
|
|
void AddPartialResults(
|
|
const rtc::scoped_refptr<RTCStatsReport>& partial_report);
|
|
|
|
private:
|
|
void AddPartialResults_s(rtc::scoped_refptr<RTCStatsReport> partial_report);
|
|
void DeliverCachedReport();
|
|
|
|
std::unique_ptr<RTCPeerConnectionStats> ProducePeerConnectionStats_s(
|
|
int64_t timestamp_us) const;
|
|
|
|
PeerConnection* const pc_;
|
|
rtc::Thread* const signaling_thread_;
|
|
rtc::Thread* const worker_thread_;
|
|
rtc::Thread* const network_thread_;
|
|
rtc::AsyncInvoker invoker_;
|
|
|
|
int num_pending_partial_reports_;
|
|
int64_t partial_report_timestamp_us_;
|
|
rtc::scoped_refptr<RTCStatsReport> partial_report_;
|
|
std::vector<rtc::scoped_refptr<RTCStatsCollectorCallback>> callbacks_;
|
|
|
|
// A timestamp, in microseconds, that is based on a timer that is
|
|
// monotonically increasing. That is, even if the system clock is modified the
|
|
// difference between the timer and this timestamp is how fresh the cached
|
|
// report is.
|
|
int64_t cache_timestamp_us_;
|
|
int64_t cache_lifetime_us_;
|
|
rtc::scoped_refptr<const RTCStatsReport> cached_report_;
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // WEBRTC_API_RTCSTATSCOLLECTOR_H_
|