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/pc/statscollector_unittest.cc b/pc/statscollector_unittest.cc
index ffb0a5a..58fdb80 100644
--- a/pc/statscollector_unittest.cc
+++ b/pc/statscollector_unittest.cc
@@ -194,8 +194,9 @@
 
 // Finds the |n|-th report of type |type| in |reports|.
 // |n| starts from 1 for finding the first report.
-const StatsReport* FindNthReportByType(
-    const StatsReports& reports, const StatsReport::StatsType& type, int n) {
+const StatsReport* FindNthReportByType(const StatsReports& reports,
+                                       const StatsReport::StatsType& type,
+                                       int n) {
   for (size_t i = 0; i < reports.size(); ++i) {
     if (reports[i]->type() == type) {
       n--;
@@ -222,19 +223,16 @@
 
 std::string ExtractBweStatsValue(const StatsReports& reports,
                                  StatsReport::StatsValueName name) {
-  return ExtractStatsValue(
-      StatsReport::kStatsReportTypeBwe, reports, name);
+  return ExtractStatsValue(StatsReport::kStatsReportTypeBwe, reports, name);
 }
 
 std::string DerToPem(const std::string& der) {
   return rtc::SSLIdentity::DerToPem(
-        rtc::kPemTypeCertificate,
-        reinterpret_cast<const unsigned char*>(der.c_str()),
-        der.length());
+      rtc::kPemTypeCertificate,
+      reinterpret_cast<const unsigned char*>(der.c_str()), der.length());
 }
 
-std::vector<std::string> DersToPems(
-    const std::vector<std::string>& ders) {
+std::vector<std::string> DersToPems(const std::vector<std::string>& ders) {
   std::vector<std::string> pems(ders.size());
   std::transform(ders.begin(), ders.end(), pems.begin(), DerToPem);
   return pems;
@@ -251,16 +249,14 @@
     ASSERT_TRUE(report != NULL);
 
     std::string der_base64;
-    EXPECT_TRUE(GetValue(
-        report, StatsReport::kStatsValueNameDer, &der_base64));
+    EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDer, &der_base64));
     std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);
     EXPECT_EQ(ders[i], der);
 
     std::string fingerprint_algorithm;
-    EXPECT_TRUE(GetValue(
-        report,
-        StatsReport::kStatsValueNameFingerprintAlgorithm,
-        &fingerprint_algorithm));
+    EXPECT_TRUE(GetValue(report,
+                         StatsReport::kStatsValueNameFingerprintAlgorithm,
+                         &fingerprint_algorithm));
     // The digest algorithm for a FakeSSLCertificate is always SHA-1.
     std::string sha_1_str = rtc::DIGEST_SHA_1;
     EXPECT_EQ(sha_1_str, fingerprint_algorithm);
@@ -272,8 +268,7 @@
 
     ++i;
     std::string issuer_id;
-    if (!GetValue(report, StatsReport::kStatsValueNameIssuerId,
-                  &issuer_id)) {
+    if (!GetValue(report, StatsReport::kStatsValueNameIssuerId, &issuer_id)) {
       break;
     }
 
@@ -283,35 +278,34 @@
   EXPECT_EQ(ders.size(), i);
 }
 
-void VerifyVoiceReceiverInfoReport(
-    const StatsReport* report,
-    const cricket::VoiceReceiverInfo& info) {
+void VerifyVoiceReceiverInfoReport(const StatsReport* report,
+                                   const cricket::VoiceReceiverInfo& info) {
   std::string value_in_report;
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameAudioOutputLevel, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioOutputLevel,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.audio_level), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameBytesReceived, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesReceived,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int64_t>(info.bytes_rcvd), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.jitter_ms), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameJitterBufferMs, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterBufferMs,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_ms), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNamePreferredJitterBufferMs,
-      &value_in_report));
+  EXPECT_TRUE(GetValue(report,
+                       StatsReport::kStatsValueNamePreferredJitterBufferMs,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_preferred_ms),
-      value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameCurrentDelayMs, &value_in_report));
+            value_in_report);
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCurrentDelayMs,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.delay_estimate_ms), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameExpandRate, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameExpandRate,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<float>(info.expand_rate), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameSpeechExpandRate, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSpeechExpandRate,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<float>(info.speech_expand_rate), value_in_report);
   EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate,
                        &value_in_report));
@@ -327,28 +321,27 @@
                        &value_in_report));
   EXPECT_EQ(rtc::ToString<float>(info.secondary_discarded_rate),
             value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNamePacketsReceived, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsReceived,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.packets_rcvd), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameDecodingCTSG, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTSG,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_silence_generator),
-      value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameDecodingCTN, &value_in_report));
-  EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_neteq),
-      value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameDecodingNormal, &value_in_report));
+            value_in_report);
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTN,
+                       &value_in_report));
+  EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_neteq), value_in_report);
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingNormal,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.decoding_normal), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameDecodingPLC, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLC,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.decoding_plc), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameDecodingCNG, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCNG,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.decoding_cng), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameDecodingPLCCNG, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLCCNG,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(info.decoding_plc_cng), value_in_report);
   EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingMutedOutput,
                        &value_in_report));
@@ -357,30 +350,29 @@
                        &value_in_report));
 }
 
-
 void VerifyVoiceSenderInfoReport(const StatsReport* report,
                                  const cricket::VoiceSenderInfo& sinfo) {
   std::string value_in_report;
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameCodecName, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
+                       &value_in_report));
   EXPECT_EQ(sinfo.codec_name, value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameBytesSent, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesSent,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int64_t>(sinfo.bytes_sent), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNamePacketsSent, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsSent,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.packets_sent), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNamePacketsLost, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.packets_lost), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameRtt, &value_in_report));
+  EXPECT_TRUE(
+      GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameRtt, &value_in_report));
+  EXPECT_TRUE(
+      GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
+                       &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.jitter_ms), value_in_report);
   if (sinfo.apm_statistics.delay_median_ms) {
     EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
@@ -449,8 +441,8 @@
   EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
                        &value_in_report));
   EXPECT_EQ(rtc::ToString<int>(sinfo.audio_level), value_in_report);
-  EXPECT_TRUE(GetValue(
-      report, StatsReport::kStatsValueNameTypingNoiseState, &value_in_report));
+  EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameTypingNoiseState,
+                       &value_in_report));
   std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";
   EXPECT_EQ(typing_detected, value_in_report);
   EXPECT_TRUE(GetValue(report,
@@ -564,9 +556,7 @@
   explicit StatsCollectorForTest(PeerConnectionInternal* pc)
       : StatsCollector(pc), time_now_(19477) {}
 
-  double GetTimeNow() override {
-    return time_now_;
-  }
+  double GetTimeNow() override { return time_now_; }
 
  private:
   double time_now_;
@@ -592,19 +582,19 @@
     stats->GetStats(nullptr, reports);
 
     // Verify the existence of the track report.
-    const StatsReport* report = FindNthReportByType(
-        *reports, StatsReport::kStatsReportTypeSsrc, 1);
+    const StatsReport* report =
+        FindNthReportByType(*reports, StatsReport::kStatsReportTypeSsrc, 1);
     ASSERT_TRUE(report);
     EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
-    std::string track_id = ExtractSsrcStatsValue(
-        *reports, StatsReport::kStatsValueNameTrackId);
+    std::string track_id =
+        ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameTrackId);
     EXPECT_EQ(audio_track->id(), track_id);
-    std::string ssrc_id = ExtractSsrcStatsValue(
-        *reports, StatsReport::kStatsValueNameSsrc);
+    std::string ssrc_id =
+        ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameSsrc);
     EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
-    std::string media_type = ExtractSsrcStatsValue(*reports,
-        StatsReport::kStatsValueNameMediaType);
+    std::string media_type =
+        ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameMediaType);
     EXPECT_EQ("audio", media_type);
 
     // Verifies the values in the track report.
@@ -625,8 +615,8 @@
     track_id = ExtractSsrcStatsValue(track_reports,
                                      StatsReport::kStatsValueNameTrackId);
     EXPECT_EQ(audio_track->id(), track_id);
-    ssrc_id = ExtractSsrcStatsValue(track_reports,
-                                    StatsReport::kStatsValueNameSsrc);
+    ssrc_id =
+        ExtractSsrcStatsValue(track_reports, StatsReport::kStatsValueNameSsrc);
     EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
     if (!voice_info.senders.empty()) {
       VerifyVoiceSenderInfoReport(track_report, voice_info.senders[0]);
@@ -668,15 +658,14 @@
     StatsReports reports;
     stats->GetStats(nullptr, &reports);
 
-    const StatsReport* channel_report = FindNthReportByType(
-        reports, StatsReport::kStatsReportTypeComponent, 1);
+    const StatsReport* channel_report =
+        FindNthReportByType(reports, StatsReport::kStatsReportTypeComponent, 1);
     EXPECT_TRUE(channel_report);
 
     // Check local certificate chain.
-    std::string local_certificate_id = ExtractStatsValue(
-        StatsReport::kStatsReportTypeComponent,
-        reports,
-        StatsReport::kStatsValueNameLocalCertificateId);
+    std::string local_certificate_id =
+        ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
+                          StatsReport::kStatsValueNameLocalCertificateId);
     if (local_ders.size() > 0) {
       EXPECT_NE(kNotFound, local_certificate_id);
       StatsReport::Id id(IdFromCertIdString(local_certificate_id));
@@ -686,10 +675,9 @@
     }
 
     // Check remote certificate chain.
-    std::string remote_certificate_id = ExtractStatsValue(
-        StatsReport::kStatsReportTypeComponent,
-        reports,
-        StatsReport::kStatsValueNameRemoteCertificateId);
+    std::string remote_certificate_id =
+        ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
+                          StatsReport::kStatsValueNameRemoteCertificateId);
     if (remote_ders.size() > 0) {
       EXPECT_NE(kNotFound, remote_certificate_id);
       StatsReport::Id id(IdFromCertIdString(remote_certificate_id));
@@ -841,9 +829,9 @@
   EXPECT_EQ(kConnectingString,
             ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
                               StatsReport::kStatsValueNameState));
-  EXPECT_EQ("", ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
-                                  reports,
-                                  StatsReport::kStatsValueNameProtocol));
+  EXPECT_EQ("",
+            ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
+                              StatsReport::kStatsValueNameProtocol));
 }
 
 // This test verifies that 64-bit counters are passed successfully.
@@ -1018,8 +1006,7 @@
   EXPECT_EQ(0, reports[0]->timestamp());
 
   std::string trackValue =
-      ExtractStatsValue(StatsReport::kStatsReportTypeTrack,
-                        reports,
+      ExtractStatsValue(StatsReport::kStatsReportTypeTrack, reports,
                         StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, trackValue);
 }
@@ -1050,8 +1037,8 @@
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE(3u, reports.size());
-  const StatsReport* track_report = FindNthReportByType(
-      reports, StatsReport::kStatsReportTypeTrack, 1);
+  const StatsReport* track_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
   EXPECT_TRUE(track_report);
 
   // Get report for the specific |track|.
@@ -1060,21 +1047,21 @@
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE(3u, reports.size());
-  track_report = FindNthReportByType(
-      reports, StatsReport::kStatsReportTypeTrack, 1);
+  track_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
   ASSERT_TRUE(track_report);
   EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
 
-  std::string ssrc_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameSsrc);
+  std::string ssrc_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
   EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
-  std::string track_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameTrackId);
+  std::string track_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
 
-  std::string media_type = ExtractSsrcStatsValue(reports,
-      StatsReport::kStatsValueNameMediaType);
+  std::string media_type =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameMediaType);
   EXPECT_EQ("video", media_type);
 }
 
@@ -1101,10 +1088,9 @@
   StatsReports reports;
   stats->GetStats(nullptr, &reports);
 
-  std::string transport_id = ExtractStatsValue(
-      StatsReport::kStatsReportTypeSsrc,
-      reports,
-      StatsReport::kStatsValueNameTransportId);
+  std::string transport_id =
+      ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports,
+                        StatsReport::kStatsValueNameTransportId);
   ASSERT_NE(kNotFound, transport_id);
 
   // Transport id component ID will always be 1.
@@ -1136,8 +1122,8 @@
   StatsReports reports;
   stats->GetStats(nullptr, &reports);
 
-  const StatsReport* remote_report = FindNthReportByType(reports,
-      StatsReport::kStatsReportTypeRemoteSsrc, 1);
+  const StatsReport* remote_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
   EXPECT_FALSE(remote_report);
 }
 
@@ -1165,8 +1151,8 @@
   StatsReports reports;
   stats->GetStats(nullptr, &reports);
 
-  const StatsReport* remote_report = FindNthReportByType(reports,
-      StatsReport::kStatsReportTypeRemoteSsrc, 1);
+  const StatsReport* remote_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
   ASSERT_TRUE(remote_report);
   EXPECT_EQ(12345.678, remote_report->timestamp());
 }
@@ -1197,17 +1183,17 @@
   // |reports| should contain at least one session report, one track report,
   // and one ssrc report.
   EXPECT_LE(3u, reports.size());
-  const StatsReport* track_report = FindNthReportByType(
-      reports, StatsReport::kStatsReportTypeTrack, 1);
+  const StatsReport* track_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
   ASSERT_TRUE(track_report);
   EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
 
-  std::string ssrc_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameSsrc);
+  std::string ssrc_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
   EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
-  std::string track_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameTrackId);
+  std::string track_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kRemoteTrackId, track_id);
 }
 
@@ -1374,17 +1360,15 @@
   stats->GetStats(nullptr, &reports);
 
   // Check that the local certificate is absent.
-  std::string local_certificate_id = ExtractStatsValue(
-      StatsReport::kStatsReportTypeComponent,
-      reports,
-      StatsReport::kStatsValueNameLocalCertificateId);
+  std::string local_certificate_id =
+      ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
+                        StatsReport::kStatsValueNameLocalCertificateId);
   ASSERT_EQ(kNotFound, local_certificate_id);
 
   // Check that the remote certificate is absent.
-  std::string remote_certificate_id = ExtractStatsValue(
-      StatsReport::kStatsReportTypeComponent,
-      reports,
-      StatsReport::kStatsValueNameRemoteCertificateId);
+  std::string remote_certificate_id =
+      ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
+                        StatsReport::kStatsValueNameRemoteCertificateId);
   ASSERT_EQ(kNotFound, remote_certificate_id);
 
   // Check that the negotiated ciphers are absent.
@@ -1530,8 +1514,8 @@
 
   // Verify that there is no remote report for the local audio track because
   // we did not set it up.
-  const StatsReport* remote_report = FindNthReportByType(reports,
-      StatsReport::kStatsReportTypeRemoteSsrc, 1);
+  const StatsReport* remote_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
   EXPECT_TRUE(remote_report == NULL);
 }
 
@@ -1580,15 +1564,15 @@
   stats->GetStats(nullptr, &reports);
 
   // The report will exist since we don't remove them in RemoveStream().
-  const StatsReport* report = FindNthReportByType(
-      reports, StatsReport::kStatsReportTypeSsrc, 1);
+  const StatsReport* report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
   ASSERT_TRUE(report);
   EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
-  std::string track_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameTrackId);
+  std::string track_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
-  std::string ssrc_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameSsrc);
+  std::string ssrc_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
   EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
 
   // Verifies the values in the track report, no value will be changed by the
@@ -1641,24 +1625,24 @@
   StatsReports reports;  // returned values.
   stats->GetStats(audio_track_.get(), &reports);
 
-  const StatsReport* track_report = FindNthReportByType(
-      reports, StatsReport::kStatsReportTypeSsrc, 1);
+  const StatsReport* track_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
   ASSERT_TRUE(track_report);
   EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
-  std::string track_id = ExtractSsrcStatsValue(
-      reports, StatsReport::kStatsValueNameTrackId);
+  std::string track_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kLocalTrackId, track_id);
   VerifyVoiceSenderInfoReport(track_report, voice_sender_info);
 
   // Get stats for the remote track.
   reports.clear();
   stats->GetStats(remote_track.get(), &reports);
-  track_report = FindNthReportByType(reports,
-                                     StatsReport::kStatsReportTypeSsrc, 1);
+  track_report =
+      FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
   ASSERT_TRUE(track_report);
   EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
-  track_id = ExtractSsrcStatsValue(reports,
-                                   StatsReport::kStatsValueNameTrackId);
+  track_id =
+      ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
   EXPECT_EQ(kRemoteTrackId, track_id);
   VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);
 }