diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /third_party/libwebrtc/pc/legacy_stats_collector.h | |
parent | Initial commit. (diff) | |
download | thunderbird-upstream.tar.xz thunderbird-upstream.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/pc/legacy_stats_collector.h')
-rw-r--r-- | third_party/libwebrtc/pc/legacy_stats_collector.h | 216 |
1 files changed, 216 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/legacy_stats_collector.h b/third_party/libwebrtc/pc/legacy_stats_collector.h new file mode 100644 index 0000000000..cedd36c853 --- /dev/null +++ b/third_party/libwebrtc/pc/legacy_stats_collector.h @@ -0,0 +1,216 @@ +/* + * Copyright 2012 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. + */ + +// This file contains a class used for gathering statistics from an ongoing +// libjingle PeerConnection. + +#ifndef PC_LEGACY_STATS_COLLECTOR_H_ +#define PC_LEGACY_STATS_COLLECTOR_H_ + +#include <stdint.h> + +#include <algorithm> +#include <cstdint> +#include <map> +#include <memory> +#include <string> +#include <type_traits> +#include <utility> +#include <vector> + +#include "absl/types/optional.h" +#include "api/field_trials_view.h" +#include "api/legacy_stats_types.h" +#include "api/media_stream_interface.h" +#include "api/peer_connection_interface.h" +#include "api/scoped_refptr.h" +#include "p2p/base/connection_info.h" +#include "p2p/base/port.h" +#include "pc/legacy_stats_collector_interface.h" +#include "pc/peer_connection_internal.h" +#include "pc/rtp_transceiver.h" +#include "pc/transport_stats.h" +#include "rtc_base/network_constants.h" +#include "rtc_base/ssl_certificate.h" +#include "rtc_base/thread_annotations.h" + +namespace webrtc { + +// Conversion function to convert candidate type string to the corresponding one +// from enum RTCStatsIceCandidateType. +const char* IceCandidateTypeToStatsType(const std::string& candidate_type); + +// Conversion function to convert adapter type to report string which are more +// fitting to the general style of http://w3c.github.io/webrtc-stats. This is +// only used by stats collector. +const char* AdapterTypeToStatsType(rtc::AdapterType type); + +// A mapping between track ids and their StatsReport. +typedef std::map<std::string, StatsReport*> TrackIdMap; + +class LegacyStatsCollector : public LegacyStatsCollectorInterface { + public: + // The caller is responsible for ensuring that the pc outlives the + // LegacyStatsCollector instance. + explicit LegacyStatsCollector(PeerConnectionInternal* pc); + virtual ~LegacyStatsCollector(); + + // Adds a MediaStream with tracks that can be used as a `selector` in a call + // to GetStats. + void AddStream(MediaStreamInterface* stream); + void AddTrack(MediaStreamTrackInterface* track); + + // Adds a local audio track that is used for getting some voice statistics. + void AddLocalAudioTrack(AudioTrackInterface* audio_track, + uint32_t ssrc) override; + + // Removes a local audio tracks that is used for getting some voice + // statistics. + void RemoveLocalAudioTrack(AudioTrackInterface* audio_track, + uint32_t ssrc) override; + + // Gather statistics from the session and store them for future use. + void UpdateStats(PeerConnectionInterface::StatsOutputLevel level); + + // Gets a StatsReports of the last collected stats. Note that UpdateStats must + // be called before this function to get the most recent stats. `selector` is + // a track label or empty string. The most recent reports are stored in + // `reports`. + // TODO(tommi): Change this contract to accept a callback object instead + // of filling in `reports`. As is, there's a requirement that the caller + // uses `reports` immediately without allowing any async activity on + // the thread (message handling etc) and then discard the results. + void GetStats(MediaStreamTrackInterface* track, + StatsReports* reports) override; + + // Prepare a local or remote SSRC report for the given ssrc. Used internally + // in the ExtractStatsFromList template. + StatsReport* PrepareReport(bool local, + uint32_t ssrc, + const std::string& track_id, + const StatsReport::Id& transport_id, + StatsReport::Direction direction); + + StatsReport* PrepareADMReport(); + + // A track is invalid if there is no report data for it. + bool IsValidTrack(const std::string& track_id); + + // Reset the internal cache timestamp to force an update of the stats next + // time UpdateStats() is called. This call needs to be made on the signaling + // thread and should be made every time configuration changes that affect + // stats have been made. + void InvalidateCache(); + + bool UseStandardBytesStats() const { return use_standard_bytes_stats_; } + + private: + friend class LegacyStatsCollectorTest; + + // Struct that's populated on the network thread and carries the values to + // the signaling thread where the stats are added to the stats reports. + struct TransportStats { + TransportStats() = default; + TransportStats(std::string transport_name, + cricket::TransportStats transport_stats) + : name(std::move(transport_name)), stats(std::move(transport_stats)) {} + TransportStats(TransportStats&&) = default; + TransportStats(const TransportStats&) = delete; + + std::string name; + cricket::TransportStats stats; + std::unique_ptr<rtc::SSLCertificateStats> local_cert_stats; + std::unique_ptr<rtc::SSLCertificateStats> remote_cert_stats; + }; + + struct SessionStats { + SessionStats() = default; + SessionStats(SessionStats&&) = default; + SessionStats(const SessionStats&) = delete; + + SessionStats& operator=(SessionStats&&) = default; + SessionStats& operator=(SessionStats&) = delete; + + cricket::CandidateStatsList candidate_stats; + std::vector<TransportStats> transport_stats; + std::map<std::string, std::string> transport_names_by_mid; + }; + + // Overridden in unit tests to fake timing. + virtual double GetTimeNow(); + + bool CopySelectedReports(const std::string& selector, StatsReports* reports); + + // Helper method for creating IceCandidate report. `is_local` indicates + // whether this candidate is local or remote. + StatsReport* AddCandidateReport( + const cricket::CandidateStats& candidate_stats, + bool local); + + // Adds a report for this certificate and every certificate in its chain, and + // returns the leaf certificate's report (`cert_stats`'s report). + StatsReport* AddCertificateReports( + std::unique_ptr<rtc::SSLCertificateStats> cert_stats); + + StatsReport* AddConnectionInfoReport(const std::string& content_name, + int component, + int connection_id, + const StatsReport::Id& channel_report_id, + const cricket::ConnectionInfo& info); + + void ExtractDataInfo(); + + // Returns the `transport_names_by_mid` member from the SessionStats as + // gathered and used to populate the stats. + std::map<std::string, std::string> ExtractSessionInfo(); + + void ExtractBweInfo(); + void ExtractMediaInfo( + const std::map<std::string, std::string>& transport_names_by_mid); + void ExtractSenderInfo(); + webrtc::StatsReport* GetReport(const StatsReport::StatsType& type, + const std::string& id, + StatsReport::Direction direction); + + // Helper method to get stats from the local audio tracks. + void UpdateStatsFromExistingLocalAudioTracks(bool has_remote_tracks); + void UpdateReportFromAudioTrack(AudioTrackInterface* track, + StatsReport* report, + bool has_remote_tracks); + + // Helper method to update the timestamp of track records. + void UpdateTrackReports(); + + SessionStats ExtractSessionInfo_n( + const std::vector<rtc::scoped_refptr< + RtpTransceiverProxyWithInternal<RtpTransceiver>>>& transceivers, + absl::optional<std::string> sctp_transport_name, + absl::optional<std::string> sctp_mid); + void ExtractSessionInfo_s(SessionStats& session_stats); + + // A collection for all of our stats reports. + StatsCollection reports_; + TrackIdMap track_ids_; + // Raw pointer to the peer connection the statistics are gathered from. + PeerConnectionInternal* const pc_; + int64_t cache_timestamp_ms_ RTC_GUARDED_BY(pc_->signaling_thread()) = 0; + double stats_gathering_started_; + const bool use_standard_bytes_stats_; + + // TODO(tommi): We appear to be holding on to raw pointers to reference + // counted objects? We should be using scoped_refptr here. + typedef std::vector<std::pair<AudioTrackInterface*, uint32_t>> + LocalAudioTrackVector; + LocalAudioTrackVector local_audio_tracks_; +}; + +} // namespace webrtc + +#endif // PC_LEGACY_STATS_COLLECTOR_H_ |