admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use backticks not vertical bars to denote variables in comments for /logging

Browse Source 
Bug: webrtc:12338
Change-Id: I87d33f201d4acfb26ca1d2da8a52cc188ff2c791
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/226948
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34609}
This commit is contained in:
Artem Titov 2021-07-30 14:22:55 +02:00 committed by WebRTC LUCI CQ
parent 0afbae130d
commit af9a3c6676
19 changed files with 68 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
logging/rtc_event_log/encoder/blob_encoding.h
View File

@ -32,13 +32,13 @@ namespace webrtc {
// EncodeBlobs() may not fail. // EncodeBlobs() may not fail.
// EncodeBlobs() never returns the empty string. // EncodeBlobs() never returns the empty string.
// //
// Calling DecodeBlobs() on an empty string, or with |num_of_blobs| set to 0, // Calling DecodeBlobs() on an empty string, or with `num_of_blobs` set to 0,
// is an error. // is an error.
// DecodeBlobs() returns an empty vector if it fails, e.g. due to a mismatch // DecodeBlobs() returns an empty vector if it fails, e.g. due to a mismatch
// between |num_of_blobs| and |encoded_blobs|, which can happen if // between `num_of_blobs` and `encoded_blobs`, which can happen if
// |encoded_blobs| is corrupted. // `encoded_blobs` is corrupted.
// When successful, DecodeBlobs() returns a vector of string_view objects, // When successful, DecodeBlobs() returns a vector of string_view objects,
// which refer to the original input (|encoded_blobs|), and therefore may // which refer to the original input (`encoded_blobs`), and therefore may
// not outlive it. // not outlive it.
// //
// Note that the returned std::string might have been reserved for significantly // Note that the returned std::string might have been reserved for significantly

34
logging/rtc_event_log/encoder/delta_encoding.cc
View File

@ -71,8 +71,8 @@ uint64_t MaxUnsignedValueOfBitWidth(uint64_t bit_width) {
: ((static_cast<uint64_t>(1) << bit_width) - 1); : ((static_cast<uint64_t>(1) << bit_width) - 1);
} }
// Computes the delta between |previous| and |current|, under the assumption // Computes the delta between `previous` and `current`, under the assumption
// that wrap-around occurs after |width| is exceeded. // that wrap-around occurs after `width` is exceeded.
uint64_t UnsignedDelta(uint64_t previous, uint64_t current, uint64_t bit_mask) { uint64_t UnsignedDelta(uint64_t previous, uint64_t current, uint64_t bit_mask) {
return (current - previous) & bit_mask; return (current - previous) & bit_mask;
} }
@ -258,7 +258,7 @@ class FixedLengthDeltaEncoder final {
// released by it before it returns. They're mostly a convenient way to // released by it before it returns. They're mostly a convenient way to
// avoid having to pass a lot of state between different functions. // avoid having to pass a lot of state between different functions.
// Therefore, it was deemed acceptable to let them have a reference to // Therefore, it was deemed acceptable to let them have a reference to
// |values|, whose lifetime must exceed the lifetime of |this|. // `values`, whose lifetime must exceed the lifetime of `this`.
FixedLengthDeltaEncoder(const FixedLengthEncodingParameters& params, FixedLengthDeltaEncoder(const FixedLengthEncodingParameters& params,
absl::optional<uint64_t> base, absl::optional<uint64_t> base,
const std::vector<absl::optional<uint64_t>>& values, const std::vector<absl::optional<uint64_t>>& values,
@ -287,7 +287,7 @@ class FixedLengthDeltaEncoder final {
// The encoding scheme assumes that at least one value is transmitted OOB, // The encoding scheme assumes that at least one value is transmitted OOB,
// so that the first value can be encoded as a delta from that OOB value, // so that the first value can be encoded as a delta from that OOB value,
// which is |base_|. // which is `base_`.
const absl::optional<uint64_t> base_; const absl::optional<uint64_t> base_;
// The values to be encoded. // The values to be encoded.
@ -606,10 +606,10 @@ class FixedLengthDeltaDecoder final {
// will fail to decode this input, though. // will fail to decode this input, though.
static bool IsSuitableDecoderFor(const std::string& input); static bool IsSuitableDecoderFor(const std::string& input);
// Assuming that |input| is the result of fixed-size delta-encoding // Assuming that `input` is the result of fixed-size delta-encoding
// that took place with the same value to |base| and over |num_of_deltas| // that took place with the same value to `base` and over `num_of_deltas`
// original values, this will return the sequence of original values. // original values, this will return the sequence of original values.
// If an error occurs (can happen if |input| is corrupt), an empty // If an error occurs (can happen if `input` is corrupt), an empty
// vector will be returned. // vector will be returned.
static std::vector<absl::optional<uint64_t>> DecodeDeltas( static std::vector<absl::optional<uint64_t>> DecodeDeltas(
const std::string& input, const std::string& input,
@ -617,9 +617,9 @@ class FixedLengthDeltaDecoder final {
size_t num_of_deltas); size_t num_of_deltas);
private: private:
// Reads the encoding header in |input| and returns a FixedLengthDeltaDecoder // Reads the encoding header in `input` and returns a FixedLengthDeltaDecoder
// with the corresponding configuration, that can be used to decode the // with the corresponding configuration, that can be used to decode the
// values in |input|. // values in `input`.
// If the encoding header is corrupt (contains an illegal configuration), // If the encoding header is corrupt (contains an illegal configuration),
// nullptr will be returned. // nullptr will be returned.
// When a valid FixedLengthDeltaDecoder is returned, this does not mean that // When a valid FixedLengthDeltaDecoder is returned, this does not mean that
@ -633,9 +633,9 @@ class FixedLengthDeltaDecoder final {
// FixedLengthDeltaDecoder objects are to be created by DecodeDeltas() and // FixedLengthDeltaDecoder objects are to be created by DecodeDeltas() and
// released by it before it returns. They're mostly a convenient way to // released by it before it returns. They're mostly a convenient way to
// avoid having to pass a lot of state between different functions. // avoid having to pass a lot of state between different functions.
// Therefore, it was deemed acceptable that |reader| does not own the buffer // Therefore, it was deemed acceptable that `reader` does not own the buffer
// it reads, meaning the lifetime of |this| must not exceed the lifetime // it reads, meaning the lifetime of `this` must not exceed the lifetime
// of |reader|'s underlying buffer. // of `reader`'s underlying buffer.
FixedLengthDeltaDecoder(std::unique_ptr<rtc::BitBuffer> reader, FixedLengthDeltaDecoder(std::unique_ptr<rtc::BitBuffer> reader,
const FixedLengthEncodingParameters& params, const FixedLengthEncodingParameters& params,
absl::optional<uint64_t> base, absl::optional<uint64_t> base,
@ -644,17 +644,17 @@ class FixedLengthDeltaDecoder final {
// Perform the decoding using the parameters given to the ctor. // Perform the decoding using the parameters given to the ctor.
std::vector<absl::optional<uint64_t>> Decode(); std::vector<absl::optional<uint64_t>> Decode();
// Decode a varint and write it to |output|. Return value indicates success // Decode a varint and write it to `output`. Return value indicates success
// or failure. In case of failure, no guarantees are made about the contents // or failure. In case of failure, no guarantees are made about the contents
// of |output| or the results of additional reads. // of `output` or the results of additional reads.
bool ParseVarInt(uint64_t* output); bool ParseVarInt(uint64_t* output);
// Attempt to parse a delta from the input reader. // Attempt to parse a delta from the input reader.
// Returns true/false for success/failure. // Returns true/false for success/failure.
// Writes the delta into |delta| if successful. // Writes the delta into `delta` if successful.
bool ParseDelta(uint64_t* delta); bool ParseDelta(uint64_t* delta);
// Add |delta| to |base| to produce the next value in a sequence. // Add `delta` to `base` to produce the next value in a sequence.
// The delta is applied as signed/unsigned depending on the parameters // The delta is applied as signed/unsigned depending on the parameters
// given to the ctor. Wrap-around is taken into account according to the // given to the ctor. Wrap-around is taken into account according to the
// values' width, as specified by the aforementioned encoding parameters. // values' width, as specified by the aforementioned encoding parameters.
@ -674,7 +674,7 @@ class FixedLengthDeltaDecoder final {
// The encoding scheme assumes that at least one value is transmitted OOB, // The encoding scheme assumes that at least one value is transmitted OOB,
// so that the first value can be encoded as a delta from that OOB value, // so that the first value can be encoded as a delta from that OOB value,
// which is |base_|. // which is `base_`.
const absl::optional<uint64_t> base_; const absl::optional<uint64_t> base_;
// The number of values to be known to be decoded. // The number of values to be known to be decoded.

8
logging/rtc_event_log/encoder/delta_encoding.h
View File

@ -21,10 +21,10 @@
namespace webrtc { namespace webrtc {
// Encode |values| as a sequence of deltas following on |base| and return it. // Encode `values` as a sequence of deltas following on `base` and return it.
// If all of the values were equal to the base, an empty string will be // If all of the values were equal to the base, an empty string will be
// returned; this is a valid encoding of that edge case. // returned; this is a valid encoding of that edge case.
// |base| is not guaranteed to be written into |output|, and must therefore // `base` is not guaranteed to be written into `output`, and must therefore
// be provided separately to the decoder. // be provided separately to the decoder.
// This function never fails. // This function never fails.
// TODO(eladalon): Split into optional and non-optional variants (efficiency). // TODO(eladalon): Split into optional and non-optional variants (efficiency).
@ -34,8 +34,8 @@ std::string EncodeDeltas(absl::optional<uint64_t> base,
// EncodeDeltas() and DecodeDeltas() are inverse operations; // EncodeDeltas() and DecodeDeltas() are inverse operations;
// invoking DecodeDeltas() over the output of EncodeDeltas(), will return // invoking DecodeDeltas() over the output of EncodeDeltas(), will return
// the input originally given to EncodeDeltas(). // the input originally given to EncodeDeltas().
// |num_of_deltas| must be greater than zero. If input is not a valid encoding // `num_of_deltas` must be greater than zero. If input is not a valid encoding
// of |num_of_deltas| elements based on |base|, the function returns an empty // of `num_of_deltas` elements based on `base`, the function returns an empty
// vector, which signals an error. // vector, which signals an error.
// TODO(eladalon): Split into optional and non-optional variants (efficiency). // TODO(eladalon): Split into optional and non-optional variants (efficiency).
std::vector<absl::optional<uint64_t>> DecodeDeltas( std::vector<absl::optional<uint64_t>> DecodeDeltas(

10
logging/rtc_event_log/encoder/delta_encoding_unittest.cc
View File

@ -64,9 +64,9 @@ uint64_t RandomWithMaxBitWidth(Random* prng, uint64_t max_width) {
} }
} }
// Encodes |values| based on |base|, then decodes the result and makes sure // Encodes `values` based on `base`, then decodes the result and makes sure
// that it is equal to the original input. // that it is equal to the original input.
// If |encoded_string| is non-null, the encoded result will also be written // If `encoded_string` is non-null, the encoded result will also be written
// into it. // into it.
void TestEncodingAndDecoding( void TestEncodingAndDecoding(
absl::optional<uint64_t> base, absl::optional<uint64_t> base,
@ -100,7 +100,7 @@ std::vector<absl::optional<uint64_t>> CreateSequenceByLastValue(
return result; return result;
} }
// If |sequence_length| is greater than the number of deltas, the sequence of // If `sequence_length` is greater than the number of deltas, the sequence of
// deltas will wrap around. // deltas will wrap around.
std::vector<absl::optional<uint64_t>> CreateSequenceByOptionalDeltas( std::vector<absl::optional<uint64_t>> CreateSequenceByOptionalDeltas(
uint64_t first, uint64_t first,
@ -141,7 +141,7 @@ size_t EncodingLengthUpperBound(size_t delta_max_bit_width,
return delta_max_bit_width * num_of_deltas + *smallest_header_size_bytes; return delta_max_bit_width * num_of_deltas + *smallest_header_size_bytes;
} }
// If |sequence_length| is greater than the number of deltas, the sequence of // If `sequence_length` is greater than the number of deltas, the sequence of
// deltas will wrap around. // deltas will wrap around.
std::vector<absl::optional<uint64_t>> CreateSequenceByDeltas( std::vector<absl::optional<uint64_t>> CreateSequenceByDeltas(
uint64_t first, uint64_t first,
@ -502,7 +502,7 @@ TEST_P(DeltaEncodingCompressionQualityTest,
uint64_t last_element[arraysize(bases)]; uint64_t last_element[arraysize(bases)];
memcpy(last_element, bases, sizeof(bases)); memcpy(last_element, bases, sizeof(bases));
// Avoid empty |deltas| due to first element causing wrap-around. // Avoid empty `deltas` due to first element causing wrap-around.
deltas[0] = 1; deltas[0] = 1;
for (size_t i = 0; i < arraysize(last_element); ++i) { for (size_t i = 0; i < arraysize(last_element); ++i) {
last_element[i] += 1; last_element[i] += 1;

4
logging/rtc_event_log/encoder/rtc_event_log_encoder_common.h
View File

@ -55,7 +55,7 @@ uint64_t ToUnsigned(T y) {
} }
} }
// Assuming x = ToUnsigned(y), return |y|. // Assuming x = ToUnsigned(y), return `y`.
// Note: static_cast<T>(x) would work on most platforms and compilers, but // Note: static_cast<T>(x) would work on most platforms and compilers, but
// involves undefined behavior. This function is well-defined, and can be // involves undefined behavior. This function is well-defined, and can be
// optimized to a noop for 64 bit types, or a few arithmetic // optimized to a noop for 64 bit types, or a few arithmetic
@ -74,7 +74,7 @@ bool ToSigned(uint64_t x, T* y) {
using UNSIGNED_T = typename std::make_unsigned<T>::type; using UNSIGNED_T = typename std::make_unsigned<T>::type;
constexpr auto MAX_UNSIGNED_T = std::numeric_limits<UNSIGNED_T>::max(); constexpr auto MAX_UNSIGNED_T = std::numeric_limits<UNSIGNED_T>::max();
if (x > static_cast<uint64_t>(MAX_UNSIGNED_T)) { if (x > static_cast<uint64_t>(MAX_UNSIGNED_T)) {
return false; // |x| cannot be represented using a T. return false; // `x` cannot be represented using a T.
} }
if (x <= static_cast<uint64_t>(MAX_T)) { if (x <= static_cast<uint64_t>(MAX_T)) {

8
logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
View File

@ -131,7 +131,7 @@ rtclog2::BweProbeResultFailure::FailureReason ConvertToProtoFormat(
// Returns true if there are recognized extensions that we should log // Returns true if there are recognized extensions that we should log
// and false if there are no extensions or all extensions are types we don't // and false if there are no extensions or all extensions are types we don't
// log. The protobuf representation of the header configs is written to // log. The protobuf representation of the header configs is written to
// |proto_config|. // `proto_config`.
bool ConvertToProtoFormat(const std::vector<RtpExtension>& extensions, bool ConvertToProtoFormat(const std::vector<RtpExtension>& extensions,
rtclog2::RtpHeaderExtensionConfig* proto_config) { rtclog2::RtpHeaderExtensionConfig* proto_config) {
size_t unknown_extensions = 0; size_t unknown_extensions = 0;
@ -287,8 +287,8 @@ rtclog2::IceCandidatePairEvent::IceCandidatePairEventType ConvertToProtoFormat(
return rtclog2::IceCandidatePairEvent::UNKNOWN_CHECK_TYPE; return rtclog2::IceCandidatePairEvent::UNKNOWN_CHECK_TYPE;
} }
// Copies all RTCP blocks except APP, SDES and unknown from |packet| to // Copies all RTCP blocks except APP, SDES and unknown from `packet` to
// |buffer|. |buffer| must have space for at least |packet.size()| bytes. // `buffer`. `buffer` must have space for at least |packet.size()| bytes.
size_t RemoveNonAllowlistedRtcpBlocks(const rtc::Buffer& packet, size_t RemoveNonAllowlistedRtcpBlocks(const rtc::Buffer& packet,
uint8_t* buffer) { uint8_t* buffer) {
RTC_DCHECK(buffer != nullptr); RTC_DCHECK(buffer != nullptr);
@ -956,7 +956,7 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
proto_batch->set_enable_fec(base_event->config().enable_fec.value()); proto_batch->set_enable_fec(base_event->config().enable_fec.value());
if (base_event->config().enable_dtx.has_value()) if (base_event->config().enable_dtx.has_value())
proto_batch->set_enable_dtx(base_event->config().enable_dtx.value()); proto_batch->set_enable_dtx(base_event->config().enable_dtx.value());
// Note that |num_channels_deltas| encodes N as N-1, to keep deltas smaller, // Note that `num_channels_deltas` encodes N as N-1, to keep deltas smaller,
// but there's no reason to do the same for the base event's value, since // but there's no reason to do the same for the base event's value, since
// no bits will be spared. // no bits will be spared.
if (base_event->config().num_channels.has_value()) if (base_event->config().num_channels.has_value())

2
logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
View File

@ -174,7 +174,7 @@ void RtcEventLogEncoderTest::TestRtpPackets() {
extension_map = gen_.NewRtpHeaderExtensionMap(true); extension_map = gen_.NewRtpHeaderExtensionMap(true);
} }
// Simulate |event_count_| RTP packets, with SSRCs assigned randomly // Simulate `event_count_` RTP packets, with SSRCs assigned randomly
// out of the small pool above. // out of the small pool above.
std::map<uint32_t, std::vector<std::unique_ptr<EventType>>> events_by_ssrc; std::map<uint32_t, std::vector<std::unique_ptr<EventType>>> events_by_ssrc;
for (size_t i = 0; i < event_count_; ++i) { for (size_t i = 0; i < event_count_; ++i) {

10
logging/rtc_event_log/events/rtc_event_generic_ack_received.h
View File

@ -52,7 +52,7 @@ class RtcEventGenericAckReceived final : public RtcEvent {
// An identifier of the acked packet. // An identifier of the acked packet.
int64_t acked_packet_number() const { return acked_packet_number_; } int64_t acked_packet_number() const { return acked_packet_number_; }
// Timestamp when the |acked_packet_number| was received by the remote side. // Timestamp when the `acked_packet_number` was received by the remote side.
absl::optional<int64_t> receive_acked_packet_time_ms() const { absl::optional<int64_t> receive_acked_packet_time_ms() const {
return receive_acked_packet_time_ms_; return receive_acked_packet_time_ms_;
} }
@ -60,10 +60,10 @@ class RtcEventGenericAckReceived final : public RtcEvent {
private: private:
RtcEventGenericAckReceived(const RtcEventGenericAckReceived& packet); RtcEventGenericAckReceived(const RtcEventGenericAckReceived& packet);
// When the ack is received, |packet_number| identifies the packet which // When the ack is received, `packet_number` identifies the packet which
// contained an ack for |acked_packet_number|, and contains the // contained an ack for `acked_packet_number`, and contains the
// |receive_acked_packet_time_ms| on which the |acked_packet_number| was // `receive_acked_packet_time_ms` on which the `acked_packet_number` was
// received on the remote side. The |receive_acked_packet_time_ms| may be // received on the remote side. The `receive_acked_packet_time_ms` may be
// null. // null.
RtcEventGenericAckReceived( RtcEventGenericAckReceived(
int64_t timestamp_us, int64_t timestamp_us,

2
logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
View File

@ -65,7 +65,7 @@ class RtcEventRtpPacketOutgoing final : public RtcEvent {
RtcEventRtpPacketOutgoing(const RtcEventRtpPacketOutgoing& other); RtcEventRtpPacketOutgoing(const RtcEventRtpPacketOutgoing& other);
const RtpPacket packet_; const RtpPacket packet_;
// TODO(eladalon): Delete |probe_cluster_id_| along with legacy encoding. // TODO(eladalon): Delete `probe_cluster_id_` along with legacy encoding.
const int probe_cluster_id_; const int probe_cluster_id_;
}; };

8
logging/rtc_event_log/rtc_event_log2.proto
View File

@ -144,7 +144,7 @@ message IncomingRtpPackets {
optional int32 transmission_time_offset = 16; optional int32 transmission_time_offset = 16;
optional uint32 absolute_send_time = 17; optional uint32 absolute_send_time = 17;
optional uint32 video_rotation = 18; optional uint32 video_rotation = 18;
// |audio_level| and |voice_activity| are always used in conjunction. // `audio_level` and `voice_activity` are always used in conjunction.
optional uint32 audio_level = 19; optional uint32 audio_level = 19;
optional bool voice_activity = 20; optional bool voice_activity = 20;
// TODO(terelius): Add other header extensions like playout delay? // TODO(terelius): Add other header extensions like playout delay?
@ -165,7 +165,7 @@ message IncomingRtpPackets {
optional bytes transmission_time_offset_deltas = 116; optional bytes transmission_time_offset_deltas = 116;
optional bytes absolute_send_time_deltas = 117; optional bytes absolute_send_time_deltas = 117;
optional bytes video_rotation_deltas = 118; optional bytes video_rotation_deltas = 118;
// |audio_level| and |voice_activity| are always used in conjunction. // `audio_level` and `voice_activity` are always used in conjunction.
optional bytes audio_level_deltas = 119; optional bytes audio_level_deltas = 119;
optional bytes voice_activity_deltas = 120; optional bytes voice_activity_deltas = 120;
} }
@ -212,7 +212,7 @@ message OutgoingRtpPackets {
optional int32 transmission_time_offset = 16; optional int32 transmission_time_offset = 16;
optional uint32 absolute_send_time = 17; optional uint32 absolute_send_time = 17;
optional uint32 video_rotation = 18; optional uint32 video_rotation = 18;
// |audio_level| and |voice_activity| are always used in conjunction. // `audio_level` and `voice_activity` are always used in conjunction.
optional uint32 audio_level = 19; optional uint32 audio_level = 19;
optional bool voice_activity = 20; optional bool voice_activity = 20;
// TODO(terelius): Add other header extensions like playout delay? // TODO(terelius): Add other header extensions like playout delay?
@ -233,7 +233,7 @@ message OutgoingRtpPackets {
optional bytes transmission_time_offset_deltas = 116; optional bytes transmission_time_offset_deltas = 116;
optional bytes absolute_send_time_deltas = 117; optional bytes absolute_send_time_deltas = 117;
optional bytes video_rotation_deltas = 118; optional bytes video_rotation_deltas = 118;
// |audio_level| and |voice_activity| are always used in conjunction. // `audio_level` and `voice_activity` are always used in conjunction.
optional bytes audio_level_deltas = 119; optional bytes audio_level_deltas = 119;
optional bytes voice_activity_deltas = 120; optional bytes voice_activity_deltas = 120;
} }

4
logging/rtc_event_log/rtc_event_log2rtp_dump.cc
View File

@ -70,7 +70,7 @@ namespace {
using MediaType = webrtc::ParsedRtcEventLog::MediaType; using MediaType = webrtc::ParsedRtcEventLog::MediaType;
// Parses the input string for a valid SSRC. If a valid SSRC is found, it is // Parses the input string for a valid SSRC. If a valid SSRC is found, it is
// written to the output variable |ssrc|, and true is returned. Otherwise, // written to the output variable `ssrc`, and true is returned. Otherwise,
// false is returned. // false is returned.
// The empty string must be validated as true, because it is the default value // The empty string must be validated as true, because it is the default value
// of the command-line flag. In this case, no value is written to the output // of the command-line flag. In this case, no value is written to the output
@ -240,7 +240,7 @@ int main(int argc, char* argv[]) {
continue; continue;
event_processor.AddEvents(stream.incoming_packets, handle_rtp); event_processor.AddEvents(stream.incoming_packets, handle_rtp);
} }
// Note that |packet_ssrc| is the sender SSRC. An RTCP message may contain // Note that `packet_ssrc` is the sender SSRC. An RTCP message may contain
// report blocks for many streams, thus several SSRCs and they don't // report blocks for many streams, thus several SSRCs and they don't
// necessarily have to be of the same media type. We therefore don't // necessarily have to be of the same media type. We therefore don't
// support filtering of RTCP based on SSRC and media type. // support filtering of RTCP based on SSRC and media type.

12
logging/rtc_event_log/rtc_event_log_impl.cc
View File

@ -98,7 +98,7 @@ bool RtcEventLogImpl::StartLogging(std::unique_ptr<RtcEventLogOutput> output,
RTC_DCHECK_RUN_ON(&logging_state_checker_); RTC_DCHECK_RUN_ON(&logging_state_checker_);
logging_state_started_ = true; logging_state_started_ = true;
// Binding to |this| is safe because |this| outlives the |task_queue_|. // Binding to `this` is safe because `this` outlives the `task_queue_`.
task_queue_->PostTask([this, output_period_ms, timestamp_us, utc_time_us, task_queue_->PostTask([this, output_period_ms, timestamp_us, utc_time_us,
output = std::move(output)]() mutable { output = std::move(output)]() mutable {
RTC_DCHECK_RUN_ON(task_queue_.get()); RTC_DCHECK_RUN_ON(task_queue_.get());
@ -117,7 +117,7 @@ void RtcEventLogImpl::StopLogging() {
RTC_LOG(LS_INFO) << "Stopping WebRTC event log."; RTC_LOG(LS_INFO) << "Stopping WebRTC event log.";
// TODO(danilchap): Do not block current thread waiting on the task queue. // TODO(danilchap): Do not block current thread waiting on the task queue.
// It might work for now, for current callers, but disallows caller to share // It might work for now, for current callers, but disallows caller to share
// threads with the |task_queue_|. // threads with the `task_queue_`.
rtc::Event output_stopped; rtc::Event output_stopped;
StopLogging([&output_stopped]() { output_stopped.Set(); }); StopLogging([&output_stopped]() { output_stopped.Set(); });
output_stopped.Wait(rtc::Event::kForever); output_stopped.Wait(rtc::Event::kForever);
@ -142,7 +142,7 @@ void RtcEventLogImpl::StopLogging(std::function<void()> callback) {
void RtcEventLogImpl::Log(std::unique_ptr<RtcEvent> event) { void RtcEventLogImpl::Log(std::unique_ptr<RtcEvent> event) {
RTC_CHECK(event); RTC_CHECK(event);
// Binding to |this| is safe because |this| outlives the |task_queue_|. // Binding to `this` is safe because `this` outlives the `task_queue_`.
task_queue_->PostTask([this, event = std::move(event)]() mutable { task_queue_->PostTask([this, event = std::move(event)]() mutable {
RTC_DCHECK_RUN_ON(task_queue_.get()); RTC_DCHECK_RUN_ON(task_queue_.get());
LogToMemory(std::move(event)); LogToMemory(std::move(event));
@ -162,7 +162,7 @@ void RtcEventLogImpl::ScheduleOutput() {
RTC_DCHECK(output_period_ms_.has_value()); RTC_DCHECK(output_period_ms_.has_value());
if (*output_period_ms_ == kImmediateOutput) { if (*output_period_ms_ == kImmediateOutput) {
// We are already on the |task_queue_| so there is no reason to post a task // We are already on the `task_queue_` so there is no reason to post a task
// if we want to output immediately. // if we want to output immediately.
LogEventsFromMemoryToOutput(); LogEventsFromMemoryToOutput();
return; return;
@ -170,7 +170,7 @@ void RtcEventLogImpl::ScheduleOutput() {
if (!output_scheduled_) { if (!output_scheduled_) {
output_scheduled_ = true; output_scheduled_ = true;
// Binding to |this| is safe because |this| outlives the |task_queue_|. // Binding to `this` is safe because `this` outlives the `task_queue_`.
auto output_task = [this]() { auto output_task = [this]() {
RTC_DCHECK_RUN_ON(task_queue_.get()); RTC_DCHECK_RUN_ON(task_queue_.get());
if (event_output_) { if (event_output_) {
@ -205,7 +205,7 @@ void RtcEventLogImpl::LogEventsFromMemoryToOutput() {
last_output_ms_ = rtc::TimeMillis(); last_output_ms_ = rtc::TimeMillis();
// Serialize all stream configurations that haven't already been written to // Serialize all stream configurations that haven't already been written to
// this output. |num_config_events_written_| is used to track which configs we // this output. `num_config_events_written_` is used to track which configs we
// have already written. (Note that the config may have been written to // have already written. (Note that the config may have been written to
// previous outputs; configs are not discarded.) // previous outputs; configs are not discarded.)
std::string encoded_configs; std::string encoded_configs;

4
logging/rtc_event_log/rtc_event_log_impl.h
View File

@ -82,8 +82,8 @@ class RtcEventLogImpl final : public RtcEventLog {
RTC_NO_UNIQUE_ADDRESS SequenceChecker logging_state_checker_; RTC_NO_UNIQUE_ADDRESS SequenceChecker logging_state_checker_;
bool logging_state_started_ RTC_GUARDED_BY(logging_state_checker_); bool logging_state_started_ RTC_GUARDED_BY(logging_state_checker_);
// Since we are posting tasks bound to |this|, it is critical that the event // Since we are posting tasks bound to `this`, it is critical that the event
// log and its members outlive |task_queue_|. Keep the |task_queue_| // log and its members outlive `task_queue_`. Keep the `task_queue_`
// last to ensure it destructs first, or else tasks living on the queue might // last to ensure it destructs first, or else tasks living on the queue might
// access other members after they've been torn down. // access other members after they've been torn down.
std::unique_ptr<rtc::TaskQueue> task_queue_; std::unique_ptr<rtc::TaskQueue> task_queue_;

4
logging/rtc_event_log/rtc_event_log_parser.cc
View File

@ -2095,7 +2095,7 @@ std::vector<LoggedPacketInfo> ParsedRtcEventLog::GetPacketInfos(
// RTX streams don't have a unique clock offset and frequency, so // RTX streams don't have a unique clock offset and frequency, so
// the RTP timstamps can't be unwrapped. // the RTP timstamps can't be unwrapped.
// Add an offset to avoid |capture_ticks| to become negative in the case // Add an offset to avoid `capture_ticks` to become negative in the case
// of reordering. // of reordering.
constexpr int64_t kStartingCaptureTimeTicks = 90 * 48 * 10000; constexpr int64_t kStartingCaptureTimeTicks = 90 * 48 * 10000;
int64_t capture_ticks = int64_t capture_ticks =
@ -3059,7 +3059,7 @@ ParsedRtcEventLog::StoreAudioNetworkAdaptationEvent(
runtime_config.enable_dtx = proto.enable_dtx(); runtime_config.enable_dtx = proto.enable_dtx();
} }
if (proto.has_num_channels()) { if (proto.has_num_channels()) {
// Note: Encoding N as N-1 only done for |num_channels_deltas|. // Note: Encoding N as N-1 only done for `num_channels_deltas`.
runtime_config.num_channels = proto.num_channels(); runtime_config.num_channels = proto.num_channels();
} }
audio_network_adaptation_events_.emplace_back( audio_network_adaptation_events_.emplace_back(

2
logging/rtc_event_log/rtc_event_log_parser.h
View File

@ -634,7 +634,7 @@ class ParsedRtcEventLog {
const RtpHeaderExtensionMap* GetRtpHeaderExtensionMap(bool incoming, const RtpHeaderExtensionMap* GetRtpHeaderExtensionMap(bool incoming,
uint32_t ssrc); uint32_t ssrc);
// Reads packet, direction and packet length from the RTCP event at |index|, // Reads packet, direction and packet length from the RTCP event at `index`,
// and stores the values in the corresponding output parameters. // and stores the values in the corresponding output parameters.
// Each output parameter can be set to nullptr if that value isn't needed. // Each output parameter can be set to nullptr if that value isn't needed.
// NB: The packet must have space for at least IP_PACKET_SIZE bytes. // NB: The packet must have space for at least IP_PACKET_SIZE bytes.

2
logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -125,7 +125,7 @@ class RtcEventLogSession
temp_filename_ = test::OutputPath() + test_name; temp_filename_ = test::OutputPath() + test_name;
} }
// Create and buffer the config events and |num_events_before_log_start| // Create and buffer the config events and `num_events_before_log_start`
// randomized non-config events. Then call StartLogging and finally create and // randomized non-config events. Then call StartLogging and finally create and
// write the remaining non-config events. // write the remaining non-config events.
void WriteLog(EventCounts count, size_t num_events_before_log_start); void WriteLog(EventCounts count, size_t num_events_before_log_start);

8
logging/rtc_event_log/rtc_event_log_unittest_helper.h
View File

@ -98,7 +98,7 @@ class EventGenerator {
rtcp::TransportFeedback NewTransportFeedback(); rtcp::TransportFeedback NewTransportFeedback();
rtcp::LossNotification NewLossNotification(); rtcp::LossNotification NewLossNotification();
// |all_configured_exts| determines whether the RTP packet exhibits all // `all_configured_exts` determines whether the RTP packet exhibits all
// configured extensions, or a random subset thereof. // configured extensions, or a random subset thereof.
void RandomizeRtpPacket(size_t payload_size, void RandomizeRtpPacket(size_t payload_size,
size_t padding_size, size_t padding_size,
@ -107,21 +107,21 @@ class EventGenerator {
RtpPacket* rtp_packet, RtpPacket* rtp_packet,
bool all_configured_exts); bool all_configured_exts);
// |all_configured_exts| determines whether the RTP packet exhibits all // `all_configured_exts` determines whether the RTP packet exhibits all
// configured extensions, or a random subset thereof. // configured extensions, or a random subset thereof.
std::unique_ptr<RtcEventRtpPacketIncoming> NewRtpPacketIncoming( std::unique_ptr<RtcEventRtpPacketIncoming> NewRtpPacketIncoming(
uint32_t ssrc, uint32_t ssrc,
const RtpHeaderExtensionMap& extension_map, const RtpHeaderExtensionMap& extension_map,
bool all_configured_exts = true); bool all_configured_exts = true);
// |all_configured_exts| determines whether the RTP packet exhibits all // `all_configured_exts` determines whether the RTP packet exhibits all
// configured extensions, or a random subset thereof. // configured extensions, or a random subset thereof.
std::unique_ptr<RtcEventRtpPacketOutgoing> NewRtpPacketOutgoing( std::unique_ptr<RtcEventRtpPacketOutgoing> NewRtpPacketOutgoing(
uint32_t ssrc, uint32_t ssrc,
const RtpHeaderExtensionMap& extension_map, const RtpHeaderExtensionMap& extension_map,
bool all_configured_exts = true); bool all_configured_exts = true);
// |configure_all| determines whether all supported extensions are configured, // `configure_all` determines whether all supported extensions are configured,
// or a random subset. // or a random subset.
RtpHeaderExtensionMap NewRtpHeaderExtensionMap(bool configure_all = false); RtpHeaderExtensionMap NewRtpHeaderExtensionMap(bool configure_all = false);

2
logging/rtc_event_log/rtc_event_processor.cc
View File

@ -15,7 +15,7 @@ RtcEventProcessor::RtcEventProcessor() = default;
RtcEventProcessor::~RtcEventProcessor() = default; RtcEventProcessor::~RtcEventProcessor() = default;
void RtcEventProcessor::ProcessEventsInOrder() { void RtcEventProcessor::ProcessEventsInOrder() {
// |event_lists_| is a min-heap of lists ordered by the timestamp of the // `event_lists_` is a min-heap of lists ordered by the timestamp of the
// first element in the list. We therefore process the first element of the // first element in the list. We therefore process the first element of the
// first list, then reinsert the remainder of that list into the heap // first list, then reinsert the remainder of that list into the heap
// if the list still contains unprocessed elements. // if the list still contains unprocessed elements.

4
logging/rtc_event_log/rtc_event_processor.h
View File

@ -98,7 +98,7 @@ class RtcEventProcessor {
// The elements of each list is processed in the index order. To process all // The elements of each list is processed in the index order. To process all
// elements in all lists in timestamp order, each list needs to be sorted in // elements in all lists in timestamp order, each list needs to be sorted in
// timestamp order prior to insertion. // timestamp order prior to insertion.
// N.B. |iterable| is not owned by RtcEventProcessor. The caller must ensure // N.B. `iterable` is not owned by RtcEventProcessor. The caller must ensure
// that the iterable outlives RtcEventProcessor and it must not be modified // that the iterable outlives RtcEventProcessor and it must not be modified
// until processing has finished. // until processing has finished.
template <typename Iterable> template <typename Iterable>
@ -122,7 +122,7 @@ class RtcEventProcessor {
std::unique_ptr<event_processor_impl::ProcessableEventListInterface>; std::unique_ptr<event_processor_impl::ProcessableEventListInterface>;
int insertion_order_index_ = 0; int insertion_order_index_ = 0;
std::vector<ListPtrType> event_lists_; std::vector<ListPtrType> event_lists_;
// Comparison function to make |event_lists_| into a min heap. // Comparison function to make `event_lists_` into a min heap.
static bool Cmp(const ListPtrType& a, const ListPtrType& b); static bool Cmp(const ListPtrType& a, const ListPtrType& b);
}; };