Reformat the WebRTC code base

Running clang-format with chromium's style guide.

The goal is n-fold:
 * providing consistency and readability (that's what code guidelines are for)
 * preventing noise with presubmit checks and git cl format
 * building on the previous point: making it easier to automatically fix format issues
 * you name it

Please consider using git-hyper-blame to ignore this commit.

Bug: webrtc:9340
Change-Id: I694567c4cdf8cee2860958cfe82bfaf25848bb87
Reviewed-on: https://webrtc-review.googlesource.com/81185
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23660}
diff --git a/stats/rtcstats.cc b/stats/rtcstats.cc
index e4460bd..0a348e9 100644
--- a/stats/rtcstats.cc
+++ b/stats/rtcstats.cc
@@ -21,7 +21,7 @@
 
 // Produces "[a,b,c]". Works for non-vector |RTCStatsMemberInterface::Type|
 // types.
-template<typename T>
+template <typename T>
 std::string VectorToString(const std::vector<T>& vector) {
   if (vector.empty())
     return "[]";
@@ -36,7 +36,7 @@
 
 // Produces "[\"a\",\"b\",\"c\"]". Works for vectors of both const char* and
 // std::string element types.
-template<typename T>
+template <typename T>
 std::string VectorOfStringsToString(const std::vector<T>& strings) {
   if (strings.empty())
     return "[]";
@@ -118,8 +118,7 @@
 }
 
 std::vector<const RTCStatsMemberInterface*>
-RTCStats::MembersOfThisObjectAndAncestors(
-    size_t additional_capacity) const {
+RTCStats::MembersOfThisObjectAndAncestors(size_t additional_capacity) const {
   std::vector<const RTCStatsMemberInterface*> members;
   members.reserve(additional_capacity);
   return members;
@@ -184,12 +183,7 @@
                              false,
                              rtc::ToString(value_),
                              ToStringAsDouble(value_));
-WEBRTC_DEFINE_RTCSTATSMEMBER(std::string,
-                             kString,
-                             false,
-                             true,
-                             value_,
-                             value_);
+WEBRTC_DEFINE_RTCSTATSMEMBER(std::string, kString, false, true, value_, value_);
 WEBRTC_DEFINE_RTCSTATSMEMBER(std::vector<bool>,
                              kSequenceBool,
                              true,
diff --git a/stats/rtcstats_objects.cc b/stats/rtcstats_objects.cc
index 7b697f0..b711a27 100644
--- a/stats/rtcstats_objects.cc
+++ b/stats/rtcstats_objects.cc
@@ -55,31 +55,25 @@
     &issuer_certificate_id);
 // clang-format on
 
-RTCCertificateStats::RTCCertificateStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCCertificateStats(std::string(id), timestamp_us) {
-}
+RTCCertificateStats::RTCCertificateStats(const std::string& id,
+                                         int64_t timestamp_us)
+    : RTCCertificateStats(std::string(id), timestamp_us) {}
 
-RTCCertificateStats::RTCCertificateStats(
-    std::string&& id, int64_t timestamp_us)
+RTCCertificateStats::RTCCertificateStats(std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       fingerprint("fingerprint"),
       fingerprint_algorithm("fingerprintAlgorithm"),
       base64_certificate("base64Certificate"),
-      issuer_certificate_id("issuerCertificateId") {
-}
+      issuer_certificate_id("issuerCertificateId") {}
 
-RTCCertificateStats::RTCCertificateStats(
-    const RTCCertificateStats& other)
+RTCCertificateStats::RTCCertificateStats(const RTCCertificateStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       fingerprint(other.fingerprint),
       fingerprint_algorithm(other.fingerprint_algorithm),
       base64_certificate(other.base64_certificate),
-      issuer_certificate_id(other.issuer_certificate_id) {
-}
+      issuer_certificate_id(other.issuer_certificate_id) {}
 
-RTCCertificateStats::~RTCCertificateStats() {
-}
+RTCCertificateStats::~RTCCertificateStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCCodecStats, RTCStats, "codec",
@@ -91,35 +85,28 @@
     &implementation);
 // clang-format on
 
-RTCCodecStats::RTCCodecStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCCodecStats(std::string(id), timestamp_us) {
-}
+RTCCodecStats::RTCCodecStats(const std::string& id, int64_t timestamp_us)
+    : RTCCodecStats(std::string(id), timestamp_us) {}
 
-RTCCodecStats::RTCCodecStats(
-    std::string&& id, int64_t timestamp_us)
+RTCCodecStats::RTCCodecStats(std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       payload_type("payloadType"),
       mime_type("mimeType"),
       clock_rate("clockRate"),
       channels("channels"),
       sdp_fmtp_line("sdpFmtpLine"),
-      implementation("implementation") {
-}
+      implementation("implementation") {}
 
-RTCCodecStats::RTCCodecStats(
-    const RTCCodecStats& other)
+RTCCodecStats::RTCCodecStats(const RTCCodecStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       payload_type(other.payload_type),
       mime_type(other.mime_type),
       clock_rate(other.clock_rate),
       channels(other.channels),
       sdp_fmtp_line(other.sdp_fmtp_line),
-      implementation(other.implementation) {
-}
+      implementation(other.implementation) {}
 
-RTCCodecStats::~RTCCodecStats() {
-}
+RTCCodecStats::~RTCCodecStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCDataChannelStats, RTCStats, "data-channel",
@@ -133,13 +120,11 @@
     &bytes_received);
 // clang-format on
 
-RTCDataChannelStats::RTCDataChannelStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCDataChannelStats(std::string(id), timestamp_us) {
-}
+RTCDataChannelStats::RTCDataChannelStats(const std::string& id,
+                                         int64_t timestamp_us)
+    : RTCDataChannelStats(std::string(id), timestamp_us) {}
 
-RTCDataChannelStats::RTCDataChannelStats(
-    std::string&& id, int64_t timestamp_us)
+RTCDataChannelStats::RTCDataChannelStats(std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       label("label"),
       protocol("protocol"),
@@ -148,11 +133,9 @@
       messages_sent("messagesSent"),
       bytes_sent("bytesSent"),
       messages_received("messagesReceived"),
-      bytes_received("bytesReceived") {
-}
+      bytes_received("bytesReceived") {}
 
-RTCDataChannelStats::RTCDataChannelStats(
-    const RTCDataChannelStats& other)
+RTCDataChannelStats::RTCDataChannelStats(const RTCDataChannelStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       label(other.label),
       protocol(other.protocol),
@@ -161,11 +144,9 @@
       messages_sent(other.messages_sent),
       bytes_sent(other.bytes_sent),
       messages_received(other.messages_received),
-      bytes_received(other.bytes_received) {
-}
+      bytes_received(other.bytes_received) {}
 
-RTCDataChannelStats::~RTCDataChannelStats() {
-}
+RTCDataChannelStats::~RTCDataChannelStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCIceCandidatePairStats, RTCStats, "candidate-pair",
@@ -195,13 +176,12 @@
     &consent_responses_sent);
 // clang-format on
 
-RTCIceCandidatePairStats::RTCIceCandidatePairStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCIceCandidatePairStats(std::string(id), timestamp_us) {
-}
+RTCIceCandidatePairStats::RTCIceCandidatePairStats(const std::string& id,
+                                                   int64_t timestamp_us)
+    : RTCIceCandidatePairStats(std::string(id), timestamp_us) {}
 
-RTCIceCandidatePairStats::RTCIceCandidatePairStats(
-    std::string&& id, int64_t timestamp_us)
+RTCIceCandidatePairStats::RTCIceCandidatePairStats(std::string&& id,
+                                                   int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       transport_id("transportId"),
       local_candidate_id("localCandidateId"),
@@ -226,8 +206,7 @@
       consent_requests_received("consentRequestsReceived"),
       consent_requests_sent("consentRequestsSent"),
       consent_responses_received("consentResponsesReceived"),
-      consent_responses_sent("consentResponsesSent") {
-}
+      consent_responses_sent("consentResponsesSent") {}
 
 RTCIceCandidatePairStats::RTCIceCandidatePairStats(
     const RTCIceCandidatePairStats& other)
@@ -255,11 +234,9 @@
       consent_requests_received(other.consent_requests_received),
       consent_requests_sent(other.consent_requests_sent),
       consent_responses_received(other.consent_responses_received),
-      consent_responses_sent(other.consent_responses_sent) {
-}
+      consent_responses_sent(other.consent_responses_sent) {}
 
-RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {
-}
+RTCIceCandidatePairStats::~RTCIceCandidatePairStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCIceCandidateStats, RTCStats, "abstract-ice-candidate",
@@ -275,10 +252,10 @@
     &deleted);
 // clang-format on
 
-RTCIceCandidateStats::RTCIceCandidateStats(
-    const std::string& id, int64_t timestamp_us, bool is_remote)
-    : RTCIceCandidateStats(std::string(id), timestamp_us, is_remote) {
-}
+RTCIceCandidateStats::RTCIceCandidateStats(const std::string& id,
+                                           int64_t timestamp_us,
+                                           bool is_remote)
+    : RTCIceCandidateStats(std::string(id), timestamp_us, is_remote) {}
 
 RTCIceCandidateStats::RTCIceCandidateStats(std::string&& id,
                                            int64_t timestamp_us,
@@ -308,20 +285,17 @@
       url(other.url),
       deleted(other.deleted) {}
 
-RTCIceCandidateStats::~RTCIceCandidateStats() {
-}
+RTCIceCandidateStats::~RTCIceCandidateStats() {}
 
 const char RTCLocalIceCandidateStats::kType[] = "local-candidate";
 
-RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCIceCandidateStats(id, timestamp_us, false) {
-}
+RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(const std::string& id,
+                                                     int64_t timestamp_us)
+    : RTCIceCandidateStats(id, timestamp_us, false) {}
 
-RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(
-    std::string&& id, int64_t timestamp_us)
-    : RTCIceCandidateStats(std::move(id), timestamp_us, false) {
-}
+RTCLocalIceCandidateStats::RTCLocalIceCandidateStats(std::string&& id,
+                                                     int64_t timestamp_us)
+    : RTCIceCandidateStats(std::move(id), timestamp_us, false) {}
 
 std::unique_ptr<RTCStats> RTCLocalIceCandidateStats::copy() const {
   return std::unique_ptr<RTCStats>(new RTCLocalIceCandidateStats(*this));
@@ -333,15 +307,13 @@
 
 const char RTCRemoteIceCandidateStats::kType[] = "remote-candidate";
 
-RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCIceCandidateStats(id, timestamp_us, true) {
-}
+RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(const std::string& id,
+                                                       int64_t timestamp_us)
+    : RTCIceCandidateStats(id, timestamp_us, true) {}
 
-RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(
-    std::string&& id, int64_t timestamp_us)
-    : RTCIceCandidateStats(std::move(id), timestamp_us, true) {
-}
+RTCRemoteIceCandidateStats::RTCRemoteIceCandidateStats(std::string&& id,
+                                                       int64_t timestamp_us)
+    : RTCIceCandidateStats(std::move(id), timestamp_us, true) {}
 
 std::unique_ptr<RTCStats> RTCRemoteIceCandidateStats::copy() const {
   return std::unique_ptr<RTCStats>(new RTCRemoteIceCandidateStats(*this));
@@ -357,27 +329,21 @@
     &track_ids);
 // clang-format on
 
-RTCMediaStreamStats::RTCMediaStreamStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCMediaStreamStats(std::string(id), timestamp_us) {
-}
+RTCMediaStreamStats::RTCMediaStreamStats(const std::string& id,
+                                         int64_t timestamp_us)
+    : RTCMediaStreamStats(std::string(id), timestamp_us) {}
 
-RTCMediaStreamStats::RTCMediaStreamStats(
-    std::string&& id, int64_t timestamp_us)
+RTCMediaStreamStats::RTCMediaStreamStats(std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       stream_identifier("streamIdentifier"),
-      track_ids("trackIds") {
-}
+      track_ids("trackIds") {}
 
-RTCMediaStreamStats::RTCMediaStreamStats(
-    const RTCMediaStreamStats& other)
+RTCMediaStreamStats::RTCMediaStreamStats(const RTCMediaStreamStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       stream_identifier(other.stream_identifier),
-      track_ids(other.track_ids) {
-}
+      track_ids(other.track_ids) {}
 
-RTCMediaStreamStats::~RTCMediaStreamStats() {
-}
+RTCMediaStreamStats::~RTCMediaStreamStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCMediaStreamTrackStats, RTCStats, "track",
@@ -408,10 +374,10 @@
                      &concealment_events);
 // clang-format on
 
-RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(
-    const std::string& id, int64_t timestamp_us, const char* kind)
-    : RTCMediaStreamTrackStats(std::string(id), timestamp_us, kind) {
-}
+RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(const std::string& id,
+                                                   int64_t timestamp_us,
+                                                   const char* kind)
+    : RTCMediaStreamTrackStats(std::string(id), timestamp_us, kind) {}
 
 RTCMediaStreamTrackStats::RTCMediaStreamTrackStats(std::string&& id,
                                                    int64_t timestamp_us,
@@ -475,8 +441,7 @@
       concealed_samples(other.concealed_samples),
       concealment_events(other.concealment_events) {}
 
-RTCMediaStreamTrackStats::~RTCMediaStreamTrackStats() {
-}
+RTCMediaStreamTrackStats::~RTCMediaStreamTrackStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCPeerConnectionStats, RTCStats, "peer-connection",
@@ -484,27 +449,23 @@
     &data_channels_closed);
 // clang-format on
 
-RTCPeerConnectionStats::RTCPeerConnectionStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCPeerConnectionStats(std::string(id), timestamp_us) {
-}
+RTCPeerConnectionStats::RTCPeerConnectionStats(const std::string& id,
+                                               int64_t timestamp_us)
+    : RTCPeerConnectionStats(std::string(id), timestamp_us) {}
 
-RTCPeerConnectionStats::RTCPeerConnectionStats(
-    std::string&& id, int64_t timestamp_us)
+RTCPeerConnectionStats::RTCPeerConnectionStats(std::string&& id,
+                                               int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       data_channels_opened("dataChannelsOpened"),
-      data_channels_closed("dataChannelsClosed") {
-}
+      data_channels_closed("dataChannelsClosed") {}
 
 RTCPeerConnectionStats::RTCPeerConnectionStats(
     const RTCPeerConnectionStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       data_channels_opened(other.data_channels_opened),
-      data_channels_closed(other.data_channels_closed) {
-}
+      data_channels_closed(other.data_channels_closed) {}
 
-RTCPeerConnectionStats::~RTCPeerConnectionStats() {
-}
+RTCPeerConnectionStats::~RTCPeerConnectionStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCRTPStreamStats, RTCStats, "rtp",
@@ -522,13 +483,11 @@
     &qp_sum);
 // clang-format on
 
-RTCRTPStreamStats::RTCRTPStreamStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCRTPStreamStats(std::string(id), timestamp_us) {
-}
+RTCRTPStreamStats::RTCRTPStreamStats(const std::string& id,
+                                     int64_t timestamp_us)
+    : RTCRTPStreamStats(std::string(id), timestamp_us) {}
 
-RTCRTPStreamStats::RTCRTPStreamStats(
-    std::string&& id, int64_t timestamp_us)
+RTCRTPStreamStats::RTCRTPStreamStats(std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       ssrc("ssrc"),
       associate_stats_id("associateStatsId"),
@@ -541,11 +500,9 @@
       pli_count("pliCount"),
       nack_count("nackCount"),
       sli_count("sliCount"),
-      qp_sum("qpSum") {
-}
+      qp_sum("qpSum") {}
 
-RTCRTPStreamStats::RTCRTPStreamStats(
-    const RTCRTPStreamStats& other)
+RTCRTPStreamStats::RTCRTPStreamStats(const RTCRTPStreamStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       ssrc(other.ssrc),
       associate_stats_id(other.associate_stats_id),
@@ -558,11 +515,9 @@
       pli_count(other.pli_count),
       nack_count(other.nack_count),
       sli_count(other.sli_count),
-      qp_sum(other.qp_sum) {
-}
+      qp_sum(other.qp_sum) {}
 
-RTCRTPStreamStats::~RTCRTPStreamStats() {
-}
+RTCRTPStreamStats::~RTCRTPStreamStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(
@@ -586,13 +541,12 @@
     &frames_decoded);
 // clang-format on
 
-RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCInboundRTPStreamStats(std::string(id), timestamp_us) {
-}
+RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(const std::string& id,
+                                                   int64_t timestamp_us)
+    : RTCInboundRTPStreamStats(std::string(id), timestamp_us) {}
 
-RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
-    std::string&& id, int64_t timestamp_us)
+RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(std::string&& id,
+                                                   int64_t timestamp_us)
     : RTCRTPStreamStats(std::move(id), timestamp_us),
       packets_received("packetsReceived"),
       bytes_received("bytesReceived"),
@@ -610,8 +564,7 @@
       burst_discard_rate("burstDiscardRate"),
       gap_loss_rate("gapLossRate"),
       gap_discard_rate("gapDiscardRate"),
-      frames_decoded("framesDecoded") {
-}
+      frames_decoded("framesDecoded") {}
 
 RTCInboundRTPStreamStats::RTCInboundRTPStreamStats(
     const RTCInboundRTPStreamStats& other)
@@ -632,11 +585,9 @@
       burst_discard_rate(other.burst_discard_rate),
       gap_loss_rate(other.gap_loss_rate),
       gap_discard_rate(other.gap_discard_rate),
-      frames_decoded(other.frames_decoded) {
-}
+      frames_decoded(other.frames_decoded) {}
 
-RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {
-}
+RTCInboundRTPStreamStats::~RTCInboundRTPStreamStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(
@@ -647,19 +598,17 @@
     &frames_encoded);
 // clang-format on
 
-RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCOutboundRTPStreamStats(std::string(id), timestamp_us) {
-}
+RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(const std::string& id,
+                                                     int64_t timestamp_us)
+    : RTCOutboundRTPStreamStats(std::string(id), timestamp_us) {}
 
-RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
-    std::string&& id, int64_t timestamp_us)
+RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(std::string&& id,
+                                                     int64_t timestamp_us)
     : RTCRTPStreamStats(std::move(id), timestamp_us),
       packets_sent("packetsSent"),
       bytes_sent("bytesSent"),
       target_bitrate("targetBitrate"),
-      frames_encoded("framesEncoded") {
-}
+      frames_encoded("framesEncoded") {}
 
 RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
     const RTCOutboundRTPStreamStats& other)
@@ -667,11 +616,9 @@
       packets_sent(other.packets_sent),
       bytes_sent(other.bytes_sent),
       target_bitrate(other.target_bitrate),
-      frames_encoded(other.frames_encoded) {
-}
+      frames_encoded(other.frames_encoded) {}
 
-RTCOutboundRTPStreamStats::~RTCOutboundRTPStreamStats() {
-}
+RTCOutboundRTPStreamStats::~RTCOutboundRTPStreamStats() {}
 
 // clang-format off
 WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport",
@@ -684,13 +631,11 @@
     &remote_certificate_id);
 // clang-format on
 
-RTCTransportStats::RTCTransportStats(
-    const std::string& id, int64_t timestamp_us)
-    : RTCTransportStats(std::string(id), timestamp_us) {
-}
+RTCTransportStats::RTCTransportStats(const std::string& id,
+                                     int64_t timestamp_us)
+    : RTCTransportStats(std::string(id), timestamp_us) {}
 
-RTCTransportStats::RTCTransportStats(
-    std::string&& id, int64_t timestamp_us)
+RTCTransportStats::RTCTransportStats(std::string&& id, int64_t timestamp_us)
     : RTCStats(std::move(id), timestamp_us),
       bytes_sent("bytesSent"),
       bytes_received("bytesReceived"),
@@ -698,11 +643,9 @@
       dtls_state("dtlsState"),
       selected_candidate_pair_id("selectedCandidatePairId"),
       local_certificate_id("localCertificateId"),
-      remote_certificate_id("remoteCertificateId") {
-}
+      remote_certificate_id("remoteCertificateId") {}
 
-RTCTransportStats::RTCTransportStats(
-    const RTCTransportStats& other)
+RTCTransportStats::RTCTransportStats(const RTCTransportStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
       bytes_sent(other.bytes_sent),
       bytes_received(other.bytes_received),
@@ -710,10 +653,8 @@
       dtls_state(other.dtls_state),
       selected_candidate_pair_id(other.selected_candidate_pair_id),
       local_certificate_id(other.local_certificate_id),
-      remote_certificate_id(other.remote_certificate_id) {
-}
+      remote_certificate_id(other.remote_certificate_id) {}
 
-RTCTransportStats::~RTCTransportStats() {
-}
+RTCTransportStats::~RTCTransportStats() {}
 
 }  // namespace webrtc
diff --git a/stats/rtcstats_unittest.cc b/stats/rtcstats_unittest.cc
index 7148c9f..a3f005d 100644
--- a/stats/rtcstats_unittest.cc
+++ b/stats/rtcstats_unittest.cc
@@ -42,28 +42,27 @@
   WEBRTC_RTCSTATS_DECL();
 
   RTCChildStats(const std::string& id, int64_t timestamp_us)
-      : RTCStats(id, timestamp_us),
-        child_int("childInt") {}
+      : RTCStats(id, timestamp_us), child_int("childInt") {}
 
   RTCStatsMember<int32_t> child_int;
 };
 
-WEBRTC_RTCSTATS_IMPL(RTCChildStats, RTCStats, "child-stats",
-    &child_int);
+WEBRTC_RTCSTATS_IMPL(RTCChildStats, RTCStats, "child-stats", &child_int);
 
 class RTCGrandChildStats : public RTCChildStats {
  public:
   WEBRTC_RTCSTATS_DECL();
 
   RTCGrandChildStats(const std::string& id, int64_t timestamp_us)
-      : RTCChildStats(id, timestamp_us),
-        grandchild_int("grandchildInt") {}
+      : RTCChildStats(id, timestamp_us), grandchild_int("grandchildInt") {}
 
   RTCStatsMember<int32_t> grandchild_int;
 };
 
-WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats, RTCChildStats, "grandchild-stats",
-      &grandchild_int);
+WEBRTC_RTCSTATS_IMPL(RTCGrandChildStats,
+                     RTCChildStats,
+                     "grandchild-stats",
+                     &grandchild_int);
 
 TEST(RTCStatsTest, RTCStatsAndMembers) {
   RTCTestStats stats("testId", 42);
@@ -123,7 +122,7 @@
   EXPECT_EQ(*stats.m_sequence_double, sequence_double);
   EXPECT_EQ(*stats.m_sequence_string, sequence_string);
 
-  int32_t numbers[] = { 4, 8, 15, 16, 23, 42 };
+  int32_t numbers[] = {4, 8, 15, 16, 23, 42};
   std::vector<int32_t> numbers_sequence(&numbers[0], &numbers[6]);
   stats.m_sequence_int32->clear();
   stats.m_sequence_int32->insert(stats.m_sequence_int32->end(),
@@ -156,11 +155,11 @@
   EXPECT_NE(stats_with_all_values.m_int32, stats_with_all_values.m_uint32);
 
   RTCTestStats one_member_different[] = {
-    stats_with_all_values, stats_with_all_values, stats_with_all_values,
-    stats_with_all_values, stats_with_all_values, stats_with_all_values,
-    stats_with_all_values, stats_with_all_values, stats_with_all_values,
-    stats_with_all_values, stats_with_all_values, stats_with_all_values,
-    stats_with_all_values, stats_with_all_values,
+      stats_with_all_values, stats_with_all_values, stats_with_all_values,
+      stats_with_all_values, stats_with_all_values, stats_with_all_values,
+      stats_with_all_values, stats_with_all_values, stats_with_all_values,
+      stats_with_all_values, stats_with_all_values, stats_with_all_values,
+      stats_with_all_values, stats_with_all_values,
   };
   for (size_t i = 0; i < 14; ++i) {
     EXPECT_EQ(stats_with_all_values, one_member_different[i]);
diff --git a/stats/rtcstatsreport.cc b/stats/rtcstatsreport.cc
index 0918567..33f6b6a 100644
--- a/stats/rtcstatsreport.cc
+++ b/stats/rtcstatsreport.cc
@@ -17,17 +17,12 @@
 RTCStatsReport::ConstIterator::ConstIterator(
     const rtc::scoped_refptr<const RTCStatsReport>& report,
     StatsMap::const_iterator it)
-    : report_(report),
-      it_(it) {
-}
+    : report_(report), it_(it) {}
 
 RTCStatsReport::ConstIterator::ConstIterator(const ConstIterator&& other)
-    : report_(std::move(other.report_)),
-      it_(std::move(other.it_)) {
-}
+    : report_(std::move(other.report_)), it_(std::move(other.it_)) {}
 
-RTCStatsReport::ConstIterator::~ConstIterator() {
-}
+RTCStatsReport::ConstIterator::~ConstIterator() {}
 
 RTCStatsReport::ConstIterator& RTCStatsReport::ConstIterator::operator++() {
   ++it_;
@@ -63,11 +58,9 @@
 }
 
 RTCStatsReport::RTCStatsReport(int64_t timestamp_us)
-    : timestamp_us_(timestamp_us) {
-}
+    : timestamp_us_(timestamp_us) {}
 
-RTCStatsReport::~RTCStatsReport() {
-}
+RTCStatsReport::~RTCStatsReport() {}
 
 rtc::scoped_refptr<RTCStatsReport> RTCStatsReport::Copy() const {
   rtc::scoped_refptr<RTCStatsReport> copy = Create(timestamp_us_);
@@ -78,11 +71,12 @@
 }
 
 void RTCStatsReport::AddStats(std::unique_ptr<const RTCStats> stats) {
-  auto result = stats_.insert(std::make_pair(std::string(stats->id()),
-                              std::move(stats)));
-  RTC_DCHECK(result.second) <<
-      "A stats object with ID " << result.first->second->id() << " is already "
-      "present in this stats report.";
+  auto result =
+      stats_.insert(std::make_pair(std::string(stats->id()), std::move(stats)));
+  RTC_DCHECK(result.second)
+      << "A stats object with ID " << result.first->second->id()
+      << " is already "
+         "present in this stats report.";
 }
 
 const RTCStats* RTCStatsReport::Get(const std::string& id) const {
diff --git a/stats/rtcstatsreport_unittest.cc b/stats/rtcstatsreport_unittest.cc
index 809cae1..4df99e1 100644
--- a/stats/rtcstatsreport_unittest.cc
+++ b/stats/rtcstatsreport_unittest.cc
@@ -21,42 +21,36 @@
   WEBRTC_RTCSTATS_DECL();
 
   RTCTestStats1(const std::string& id, int64_t timestamp_us)
-      : RTCStats(id, timestamp_us),
-        integer("integer") {}
+      : RTCStats(id, timestamp_us), integer("integer") {}
 
   RTCStatsMember<int32_t> integer;
 };
 
-WEBRTC_RTCSTATS_IMPL(RTCTestStats1, RTCStats, "test-stats-1",
-    &integer);
+WEBRTC_RTCSTATS_IMPL(RTCTestStats1, RTCStats, "test-stats-1", &integer);
 
 class RTCTestStats2 : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
 
   RTCTestStats2(const std::string& id, int64_t timestamp_us)
-      : RTCStats(id, timestamp_us),
-        number("number") {}
+      : RTCStats(id, timestamp_us), number("number") {}
 
   RTCStatsMember<double> number;
 };
 
-WEBRTC_RTCSTATS_IMPL(RTCTestStats2, RTCStats, "test-stats-2",
-    &number);
+WEBRTC_RTCSTATS_IMPL(RTCTestStats2, RTCStats, "test-stats-2", &number);
 
 class RTCTestStats3 : public RTCStats {
  public:
   WEBRTC_RTCSTATS_DECL();
 
   RTCTestStats3(const std::string& id, int64_t timestamp_us)
-      : RTCStats(id, timestamp_us),
-        string("string") {}
+      : RTCStats(id, timestamp_us), string("string") {}
 
   RTCStatsMember<std::string> string;
 };
 
-WEBRTC_RTCSTATS_IMPL(RTCTestStats3, RTCStats, "test-stats-3",
-    &string);
+WEBRTC_RTCSTATS_IMPL(RTCTestStats3, RTCStats, "test-stats-3", &string);
 
 TEST(RTCStatsReport, AddAndGetStats) {
   rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(1337);
diff --git a/stats/test/rtcteststats.cc b/stats/test/rtcteststats.cc
index 5b6dffa..162f329 100644
--- a/stats/test/rtcteststats.cc
+++ b/stats/test/rtcteststats.cc
@@ -12,21 +12,23 @@
 
 namespace webrtc {
 
-WEBRTC_RTCSTATS_IMPL(RTCTestStats, RTCStats, "test-stats",
-    &m_bool,
-    &m_int32,
-    &m_uint32,
-    &m_int64,
-    &m_uint64,
-    &m_double,
-    &m_string,
-    &m_sequence_bool,
-    &m_sequence_int32,
-    &m_sequence_uint32,
-    &m_sequence_int64,
-    &m_sequence_uint64,
-    &m_sequence_double,
-    &m_sequence_string);
+WEBRTC_RTCSTATS_IMPL(RTCTestStats,
+                     RTCStats,
+                     "test-stats",
+                     &m_bool,
+                     &m_int32,
+                     &m_uint32,
+                     &m_int64,
+                     &m_uint64,
+                     &m_double,
+                     &m_string,
+                     &m_sequence_bool,
+                     &m_sequence_int32,
+                     &m_sequence_uint32,
+                     &m_sequence_int64,
+                     &m_sequence_uint64,
+                     &m_sequence_double,
+                     &m_sequence_string);
 
 RTCTestStats::RTCTestStats(const std::string& id, int64_t timestamp_us)
     : RTCStats(id, timestamp_us),
@@ -43,8 +45,7 @@
       m_sequence_int64("mSequenceInt64"),
       m_sequence_uint64("mSequenceUint64"),
       m_sequence_double("mSequenceDouble"),
-      m_sequence_string("mSequenceString") {
-}
+      m_sequence_string("mSequenceString") {}
 
 RTCTestStats::RTCTestStats(const RTCTestStats& other)
     : RTCStats(other.id(), other.timestamp_us()),
@@ -61,10 +62,8 @@
       m_sequence_int64(other.m_sequence_int64),
       m_sequence_uint64(other.m_sequence_uint64),
       m_sequence_double(other.m_sequence_double),
-      m_sequence_string(other.m_sequence_string) {
-}
+      m_sequence_string(other.m_sequence_string) {}
 
-RTCTestStats::~RTCTestStats() {
-}
+RTCTestStats::~RTCTestStats() {}
 
 }  // namespace webrtc