diff --git a/logging/rtc_event_log/encoder/blob_encoding.h b/logging/rtc_event_log/encoder/blob_encoding.h
index b5b589a..123fffe 100644
--- a/logging/rtc_event_log/encoder/blob_encoding.h
+++ b/logging/rtc_event_log/encoder/blob_encoding.h
@@ -32,13 +32,13 @@
 // 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
diff --git a/logging/rtc_event_log/encoder/delta_encoding.cc b/logging/rtc_event_log/encoder/delta_encoding.cc
index 7bccdab..b62ce29 100644
--- a/logging/rtc_event_log/encoder/delta_encoding.cc
+++ b/logging/rtc_event_log/encoder/delta_encoding.cc
@@ -71,8 +71,8 @@
                            : ((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 @@
   // 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 @@
 
   // 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 @@
   // 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 @@
       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 @@
   // 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 @@
   // 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 @@
 
   // 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.
diff --git a/logging/rtc_event_log/encoder/delta_encoding.h b/logging/rtc_event_log/encoder/delta_encoding.h
index 5e86a98..614012a 100644
--- a/logging/rtc_event_log/encoder/delta_encoding.h
+++ b/logging/rtc_event_log/encoder/delta_encoding.h
@@ -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 @@
 // 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(
diff --git a/logging/rtc_event_log/encoder/delta_encoding_unittest.cc b/logging/rtc_event_log/encoder/delta_encoding_unittest.cc
index b385b89..3d91362 100644
--- a/logging/rtc_event_log/encoder/delta_encoding_unittest.cc
+++ b/logging/rtc_event_log/encoder/delta_encoding_unittest.cc
@@ -64,9 +64,9 @@
   }
 }
 
-// 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 @@
   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 @@
   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 @@
   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;
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_common.h b/logging/rtc_event_log/encoder/rtc_event_log_encoder_common.h
index 429f8ed..c167a8e 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_common.h
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_common.h
@@ -55,7 +55,7 @@
   }
 }
 
-// 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 @@
   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)) {
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
index 9400c86..4b9be76 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
@@ -131,7 +131,7 @@
 // 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 @@
   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 @@
     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())
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
index 063d425..8eddc8f 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_unittest.cc
@@ -174,7 +174,7 @@
     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) {
diff --git a/logging/rtc_event_log/events/rtc_event_generic_ack_received.h b/logging/rtc_event_log/events/rtc_event_generic_ack_received.h
index 75fc83c..3cd8f5c 100644
--- a/logging/rtc_event_log/events/rtc_event_generic_ack_received.h
+++ b/logging/rtc_event_log/events/rtc_event_generic_ack_received.h
@@ -52,7 +52,7 @@
   // 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 @@
  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,
diff --git a/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h b/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
index 9ef5b1a..626c094 100644
--- a/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
+++ b/logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h
@@ -65,7 +65,7 @@
   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_;
 };
 
diff --git a/logging/rtc_event_log/rtc_event_log2.proto b/logging/rtc_event_log/rtc_event_log2.proto
index 4ff3206..a541533 100644
--- a/logging/rtc_event_log/rtc_event_log2.proto
+++ b/logging/rtc_event_log/rtc_event_log2.proto
@@ -144,7 +144,7 @@
   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 @@
   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 @@
   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 @@
   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;
 }
diff --git a/logging/rtc_event_log/rtc_event_log2rtp_dump.cc b/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
index c9d4a6c..93cd465 100644
--- a/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
+++ b/logging/rtc_event_log/rtc_event_log2rtp_dump.cc
@@ -70,7 +70,7 @@
 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 @@
       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.
diff --git a/logging/rtc_event_log/rtc_event_log_impl.cc b/logging/rtc_event_log/rtc_event_log_impl.cc
index 700f639..38cf5f7 100644
--- a/logging/rtc_event_log/rtc_event_log_impl.cc
+++ b/logging/rtc_event_log/rtc_event_log_impl.cc
@@ -98,7 +98,7 @@
 
   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 @@
   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::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 @@
 
   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 @@
 
   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 @@
   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;
diff --git a/logging/rtc_event_log/rtc_event_log_impl.h b/logging/rtc_event_log/rtc_event_log_impl.h
index 0b6a71b..61e90d1 100644
--- a/logging/rtc_event_log/rtc_event_log_impl.h
+++ b/logging/rtc_event_log/rtc_event_log_impl.h
@@ -82,8 +82,8 @@
   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_;
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index 2e67d52..6ae4bde 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -2095,7 +2095,7 @@
       // 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 @@
       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(
diff --git a/logging/rtc_event_log/rtc_event_log_parser.h b/logging/rtc_event_log/rtc_event_log_parser.h
index d18a238..d4c8409 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.h
+++ b/logging/rtc_event_log/rtc_event_log_parser.h
@@ -634,7 +634,7 @@
   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.
diff --git a/logging/rtc_event_log/rtc_event_log_unittest.cc b/logging/rtc_event_log/rtc_event_log_unittest.cc
index 323e4fe..a494d9e 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest.cc
+++ b/logging/rtc_event_log/rtc_event_log_unittest.cc
@@ -125,7 +125,7 @@
     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);
diff --git a/logging/rtc_event_log/rtc_event_log_unittest_helper.h b/logging/rtc_event_log/rtc_event_log_unittest_helper.h
index eb16592..94a46c1 100644
--- a/logging/rtc_event_log/rtc_event_log_unittest_helper.h
+++ b/logging/rtc_event_log/rtc_event_log_unittest_helper.h
@@ -98,7 +98,7 @@
   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 @@
                           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);
 
diff --git a/logging/rtc_event_log/rtc_event_processor.cc b/logging/rtc_event_log/rtc_event_processor.cc
index 804e283..e6a9983 100644
--- a/logging/rtc_event_log/rtc_event_processor.cc
+++ b/logging/rtc_event_log/rtc_event_processor.cc
@@ -15,7 +15,7 @@
 
 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.
diff --git a/logging/rtc_event_log/rtc_event_processor.h b/logging/rtc_event_log/rtc_event_processor.h
index abb7370..9bf4c9c 100644
--- a/logging/rtc_event_log/rtc_event_processor.h
+++ b/logging/rtc_event_log/rtc_event_processor.h
@@ -98,7 +98,7 @@
   // 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 @@
       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);
 };