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() 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.
// 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
// |encoded_blobs| is corrupted.
// between `num_of_blobs` and `encoded_blobs`, which can happen if
// `encoded_blobs` is corrupted.
// 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.
//
// 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);
}
// Computes the delta between |previous| and |current|, under the assumption
// that wrap-around occurs after |width| is exceeded.
// Computes the delta between `previous` and `current`, under the assumption
// that wrap-around occurs after `width` is exceeded.
uint64_t UnsignedDelta(uint64_t previous, uint64_t current, uint64_t 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
// avoid having to pass a lot of state between different functions.
// 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,
absl::optional<uint64_t> base,
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,
// 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_;
// The values to be encoded.
@ -606,10 +606,10 @@ class FixedLengthDeltaDecoder final {
// will fail to decode this input, though.
static bool IsSuitableDecoderFor(const std::string& input);
// 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|
// 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`
// 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.
static std::vector<absl::optional<uint64_t>> DecodeDeltas(
const std::string& input,
@ -617,9 +617,9 @@ class FixedLengthDeltaDecoder final {
size_t num_of_deltas);
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
// values in |input|.
// values in `input`.
// If the encoding header is corrupt (contains an illegal configuration),
// nullptr will be returned.
// 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
// released by it before it returns. They're mostly a convenient way to
// avoid having to pass a lot of state between different functions.
// Therefore, it was deemed acceptable that |reader| does not own the buffer
// it reads, meaning the lifetime of |this| must not exceed the lifetime
// of |reader|'s underlying 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
// of `reader`'s underlying buffer.
FixedLengthDeltaDecoder(std::unique_ptr<rtc::BitBuffer> reader,
const FixedLengthEncodingParameters& params,
absl::optional<uint64_t> base,
@ -644,17 +644,17 @@ class FixedLengthDeltaDecoder final {
// Perform the decoding using the parameters given to the ctor.
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
// of |output| or the results of additional reads.
// of `output` or the results of additional reads.
bool ParseVarInt(uint64_t* output);
// Attempt to parse a delta from the input reader.
// 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);
// 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
// given to the ctor. Wrap-around is taken into account according to the
// 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,
// 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_;
// 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 {
// 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
// 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.
// This function never fails.
// 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;
// invoking DecodeDeltas() over the output of EncodeDeltas(), will return
// the input originally given to EncodeDeltas().
// |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
// `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
// vector, which signals an error.
// TODO(eladalon): Split into optional and non-optional variants (efficiency).
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.
// 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.
void TestEncodingAndDecoding(
absl::optional<uint64_t> base,
@ -100,7 +100,7 @@ std::vector<absl::optional<uint64_t>> CreateSequenceByLastValue(
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.
std::vector<absl::optional<uint64_t>> CreateSequenceByOptionalDeltas(
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;
}
// 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.
std::vector<absl::optional<uint64_t>> CreateSequenceByDeltas(
uint64_t first,
@ -502,7 +502,7 @@ TEST_P(DeltaEncodingCompressionQualityTest,
uint64_t last_element[arraysize(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;
for (size_t i = 0; i < arraysize(last_element); ++i) {
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
// involves undefined behavior. This function is well-defined, and can be
// 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;
constexpr auto MAX_UNSIGNED_T = std::numeric_limits<UNSIGNED_T>::max();
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)) {

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
// 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
// |proto_config|.
// `proto_config`.
bool ConvertToProtoFormat(const std::vector<RtpExtension>& extensions,
rtclog2::RtpHeaderExtensionConfig* proto_config) {
size_t unknown_extensions = 0;
@ -287,8 +287,8 @@ rtclog2::IceCandidatePairEvent::IceCandidatePairEventType ConvertToProtoFormat(
return rtclog2::IceCandidatePairEvent::UNKNOWN_CHECK_TYPE;
}
// Copies all RTCP blocks except APP, SDES and unknown from |packet| to
// |buffer|. |buffer| must have space for at least |packet.size()| bytes.
// Copies all RTCP blocks except APP, SDES and unknown from `packet` to
// `buffer`. `buffer` must have space for at least |packet.size()| bytes.
size_t RemoveNonAllowlistedRtcpBlocks(const rtc::Buffer& packet,
uint8_t* buffer) {
RTC_DCHECK(buffer != nullptr);
@ -956,7 +956,7 @@ void RtcEventLogEncoderNewFormat::EncodeAudioNetworkAdaptation(
proto_batch->set_enable_fec(base_event->config().enable_fec.value());
if (base_event->config().enable_dtx.has_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
// no bits will be spared.
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);
}
// Simulate |event_count_| RTP packets, with SSRCs assigned randomly
// Simulate `event_count_` RTP packets, with SSRCs assigned randomly
// out of the small pool above.
std::map<uint32_t, std::vector<std::unique_ptr<EventType>>> events_by_ssrc;
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.
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 {
return receive_acked_packet_time_ms_;
}
@ -60,10 +60,10 @@ class RtcEventGenericAckReceived final : public RtcEvent {
private:
RtcEventGenericAckReceived(const RtcEventGenericAckReceived& packet);
// When the ack is received, |packet_number| identifies the packet which
// contained an ack for |acked_packet_number|, and contains the
// |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
// When the ack is received, `packet_number` identifies the packet which
// contained an ack for `acked_packet_number`, and contains the
// `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
// null.
RtcEventGenericAckReceived(
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);
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_;
};

8
logging/rtc_event_log/rtc_event_log2.proto
View File

@ -144,7 +144,7 @@ message IncomingRtpPackets {
optional int32 transmission_time_offset = 16;
optional uint32 absolute_send_time = 17;
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 bool voice_activity = 20;
// TODO(terelius): Add other header extensions like playout delay?
@ -165,7 +165,7 @@ message IncomingRtpPackets {
optional bytes transmission_time_offset_deltas = 116;
optional bytes absolute_send_time_deltas = 117;
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 voice_activity_deltas = 120;
}
@ -212,7 +212,7 @@ message OutgoingRtpPackets {
optional int32 transmission_time_offset = 16;
optional uint32 absolute_send_time = 17;
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 bool voice_activity = 20;
// TODO(terelius): Add other header extensions like playout delay?
@ -233,7 +233,7 @@ message OutgoingRtpPackets {
optional bytes transmission_time_offset_deltas = 116;
optional bytes absolute_send_time_deltas = 117;
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 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;
// 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.
// 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
@ -240,7 +240,7 @@ int main(int argc, char* argv[]) {
continue;
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
// necessarily have to be of the same media type. We therefore don't
// 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_);
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,
output = std::move(output)]() mutable {
RTC_DCHECK_RUN_ON(task_queue_.get());
@ -117,7 +117,7 @@ void RtcEventLogImpl::StopLogging() {
RTC_LOG(LS_INFO) << "Stopping WebRTC event log.";
// 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
// threads with the |task_queue_|.
// threads with the `task_queue_`.
rtc::Event output_stopped;
StopLogging([&output_stopped]() { output_stopped.Set(); });
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) {
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 {
RTC_DCHECK_RUN_ON(task_queue_.get());
LogToMemory(std::move(event));
@ -162,7 +162,7 @@ void RtcEventLogImpl::ScheduleOutput() {
RTC_DCHECK(output_period_ms_.has_value());
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.
LogEventsFromMemoryToOutput();
return;
@ -170,7 +170,7 @@ void RtcEventLogImpl::ScheduleOutput() {
if (!output_scheduled_) {
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]() {
RTC_DCHECK_RUN_ON(task_queue_.get());
if (event_output_) {
@ -205,7 +205,7 @@ void RtcEventLogImpl::LogEventsFromMemoryToOutput() {
last_output_ms_ = rtc::TimeMillis();
// 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
// previous outputs; configs are not discarded.)
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_;
bool logging_state_started_ RTC_GUARDED_BY(logging_state_checker_);
// 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_|
// 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_`
// last to ensure it destructs first, or else tasks living on the queue might
// access other members after they've been torn down.
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
// 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.
constexpr int64_t kStartingCaptureTimeTicks = 90 * 48 * 10000;
int64_t capture_ticks =
@ -3059,7 +3059,7 @@ ParsedRtcEventLog::StoreAudioNetworkAdaptationEvent(
runtime_config.enable_dtx = proto.enable_dtx();
}
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();
}
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,
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.
// 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.

2
logging/rtc_event_log/rtc_event_log_unittest.cc
View File

@ -125,7 +125,7 @@ class RtcEventLogSession
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
// write the remaining non-config events.
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::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.
void RandomizeRtpPacket(size_t payload_size,
size_t padding_size,
@ -107,21 +107,21 @@ class EventGenerator {
RtpPacket* rtp_packet,
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.
std::unique_ptr<RtcEventRtpPacketIncoming> NewRtpPacketIncoming(
uint32_t ssrc,
const RtpHeaderExtensionMap& extension_map,
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.
std::unique_ptr<RtcEventRtpPacketOutgoing> NewRtpPacketOutgoing(
uint32_t ssrc,
const RtpHeaderExtensionMap& extension_map,
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.
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;
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 list, then reinsert the remainder of that list into the heap
// 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
// elements in all lists in timestamp order, each list needs to be sorted in
// 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
// until processing has finished.
template <typename Iterable>
@ -122,7 +122,7 @@ class RtcEventProcessor {
std::unique_ptr<event_processor_impl::ProcessableEventListInterface>;
int insertion_order_index_ = 0;
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);
};