diff --git a/rtc_base/async_resolver.cc b/rtc_base/async_resolver.cc
index 7c1a6fe..48c1613 100644
--- a/rtc_base/async_resolver.cc
+++ b/rtc_base/async_resolver.cc
@@ -152,29 +152,29 @@
   RTC_DCHECK_RUN_ON(&sequence_checker_);
   RTC_DCHECK(!destroy_called_);
   addr_ = addr;
-  auto thread_function =
-      [this, addr, family, caller_task_queue = webrtc::TaskQueueBase::Current(),
-       state = state_] {
-        std::vector<IPAddress> addresses;
-        int error = ResolveHostname(addr.hostname(), family, &addresses);
-        webrtc::MutexLock lock(&state->mutex);
-        if (state->status == State::Status::kLive) {
-          caller_task_queue->PostTask(
-              [this, error, addresses = std::move(addresses), state] {
-                bool live;
-                {
-                  // ResolveDone can lead to instance destruction, so make sure
-                  // we don't deadlock.
-                  webrtc::MutexLock lock(&state->mutex);
-                  live = state->status == State::Status::kLive;
-                }
-                if (live) {
-                  RTC_DCHECK_RUN_ON(&sequence_checker_);
-                  ResolveDone(std::move(addresses), error);
-                }
-              });
-        }
-      };
+  auto thread_function = [this, addr, family,
+                          caller_task_queue = webrtc::TaskQueueBase::Current(),
+                          state = state_] {
+    std::vector<IPAddress> addresses;
+    int error = ResolveHostname(addr.hostname(), family, &addresses);
+    webrtc::MutexLock lock(&state->mutex);
+    if (state->status == State::Status::kLive) {
+      caller_task_queue->PostTask(
+          [this, error, addresses = std::move(addresses), state] {
+            bool live;
+            {
+              // ResolveDone can lead to instance destruction, so make sure
+              // we don't deadlock.
+              webrtc::MutexLock lock(&state->mutex);
+              live = state->status == State::Status::kLive;
+            }
+            if (live) {
+              RTC_DCHECK_RUN_ON(&sequence_checker_);
+              ResolveDone(std::move(addresses), error);
+            }
+          });
+    }
+  };
 #if defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
   PostTaskToGlobalQueue(
       std::make_unique<absl::AnyInvocable<void() &&>>(thread_function));
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index d29eafd..97e8611 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -61,8 +61,7 @@
   return owned_socket.release();
 }
 
-AsyncTCPSocketBase::AsyncTCPSocketBase(Socket* socket,
-                                       size_t max_packet_size)
+AsyncTCPSocketBase::AsyncTCPSocketBase(Socket* socket, size_t max_packet_size)
     : socket_(socket),
       max_insize_(max_packet_size),
       max_outsize_(max_packet_size) {
diff --git a/rtc_base/callback_list_unittest.cc b/rtc_base/callback_list_unittest.cc
index 483eb3f..86c2009 100644
--- a/rtc_base/callback_list_unittest.cc
+++ b/rtc_base/callback_list_unittest.cc
@@ -7,11 +7,12 @@
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
+#include "rtc_base/callback_list.h"
+
 #include <string>
 #include <type_traits>
 
 #include "api/function_view.h"
-#include "rtc_base/callback_list.h"
 #include "test/gtest.h"
 
 namespace webrtc {
@@ -25,7 +26,7 @@
 
 TEST(CallbackList, MultipleParameterMessageTest) {
   CallbackList<const std::string&, std::string, std::string&&, int, int*,
-             std::string&>
+               std::string&>
       c;
   std::string str = "messege";
   int i = 10;
diff --git a/rtc_base/checks.h b/rtc_base/checks.h
index 459c6a5..99fee97 100644
--- a/rtc_base/checks.h
+++ b/rtc_base/checks.h
@@ -411,22 +411,20 @@
             ::rtc::webrtc_checks_impl::LogStreamer<>() << (val1) << (val2)
 #else
 #define RTC_CHECK(condition)                                                  \
-  (condition)                                                                 \
-      ? static_cast<void>(0)                                                  \
-      : true ? ::rtc::webrtc_checks_impl::FatalLogCall<false>(__FILE__,       \
-                                                              __LINE__, "") & \
-                   ::rtc::webrtc_checks_impl::LogStreamer<>()                 \
-             : ::rtc::webrtc_checks_impl::FatalLogCall<false>("", 0, "") &    \
-                   ::rtc::webrtc_checks_impl::LogStreamer<>()
+  (condition) ? static_cast<void>(0)                                          \
+  : true ? ::rtc::webrtc_checks_impl::FatalLogCall<false>(__FILE__, __LINE__, \
+                                                          "") &               \
+               ::rtc::webrtc_checks_impl::LogStreamer<>()                     \
+         : ::rtc::webrtc_checks_impl::FatalLogCall<false>("", 0, "") &        \
+               ::rtc::webrtc_checks_impl::LogStreamer<>()
 
 #define RTC_CHECK_OP(name, op, val1, val2)                                   \
-  ::rtc::Safe##name((val1), (val2))                                          \
-      ? static_cast<void>(0)                                                 \
-      : true ? ::rtc::webrtc_checks_impl::FatalLogCall<true>(__FILE__,       \
-                                                             __LINE__, "") & \
-                   ::rtc::webrtc_checks_impl::LogStreamer<>()                \
-             : ::rtc::webrtc_checks_impl::FatalLogCall<false>("", 0, "") &   \
-                   ::rtc::webrtc_checks_impl::LogStreamer<>()
+  ::rtc::Safe##name((val1), (val2)) ? static_cast<void>(0)                   \
+  : true ? ::rtc::webrtc_checks_impl::FatalLogCall<true>(__FILE__, __LINE__, \
+                                                         "") &               \
+               ::rtc::webrtc_checks_impl::LogStreamer<>()                    \
+         : ::rtc::webrtc_checks_impl::FatalLogCall<false>("", 0, "") &       \
+               ::rtc::webrtc_checks_impl::LogStreamer<>()
 #endif
 
 #define RTC_CHECK_EQ(val1, val2) RTC_CHECK_OP(Eq, ==, val1, val2)
diff --git a/rtc_base/event_tracer_unittest.cc b/rtc_base/event_tracer_unittest.cc
index f4d41e4..d0783c3 100644
--- a/rtc_base/event_tracer_unittest.cc
+++ b/rtc_base/event_tracer_unittest.cc
@@ -61,17 +61,11 @@
       [](const char* /*name*/) {
         return reinterpret_cast<const unsigned char*>("test");
       },
-      [](char /*phase*/,
-         const unsigned char* /*category_enabled*/,
-         const char* /*name*/,
-         unsigned long long /*id*/,
-         int /*num_args*/,
-         const char** /*arg_names*/,
-         const unsigned char* /*arg_types*/,
+      [](char /*phase*/, const unsigned char* /*category_enabled*/,
+         const char* /*name*/, unsigned long long /*id*/, int /*num_args*/,
+         const char** /*arg_names*/, const unsigned char* /*arg_types*/,
          const unsigned long long* /*arg_values*/,
-         unsigned char /*flags*/) {
-        TestStatistics::Get()->Increment();
-      });
+         unsigned char /*flags*/) { TestStatistics::Get()->Increment(); });
   { TRACE_EVENT0("test", "ScopedTraceEvent"); }
   EXPECT_EQ(2, TestStatistics::Get()->Count());
   TestStatistics::Get()->Reset();
diff --git a/rtc_base/experiments/balanced_degradation_settings.h b/rtc_base/experiments/balanced_degradation_settings.h
index 0b5e03d..2bca73d 100644
--- a/rtc_base/experiments/balanced_degradation_settings.h
+++ b/rtc_base/experiments/balanced_degradation_settings.h
@@ -96,9 +96,9 @@
 
     int pixels = 0;  // Video frame size.
     // If the frame size is less than or equal to `pixels`:
-    int fps = 0;   // Min framerate to be used.
-    int kbps = 0;  // Min bitrate needed to adapt up (resolution/fps).
-    int kbps_res = 0;           // Min bitrate needed to adapt up in resolution.
+    int fps = 0;       // Min framerate to be used.
+    int kbps = 0;      // Min bitrate needed to adapt up (resolution/fps).
+    int kbps_res = 0;  // Min bitrate needed to adapt up in resolution.
     int fps_diff = kNoFpsDiff;  // Min fps reduction needed (input fps - `fps`)
                                 // w/o triggering a new subsequent downgrade
                                 // check.
diff --git a/rtc_base/experiments/balanced_degradation_settings_unittest.cc b/rtc_base/experiments/balanced_degradation_settings_unittest.cc
index a32dbb4..996c06f 100644
--- a/rtc_base/experiments/balanced_degradation_settings_unittest.cc
+++ b/rtc_base/experiments/balanced_degradation_settings_unittest.cc
@@ -21,40 +21,39 @@
 
 void VerifyIsDefault(
     const std::vector<BalancedDegradationSettings::Config>& config) {
-  EXPECT_THAT(config, ::testing::ElementsAre(
-                          BalancedDegradationSettings::Config{
-                              320 * 240,
-                              7,
-                              0,
-                              0,
-                              BalancedDegradationSettings::kNoFpsDiff,
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0}},
-                          BalancedDegradationSettings::Config{
-                              480 * 360,
-                              10,
-                              0,
-                              0,
-                              1,
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0}},
-                          BalancedDegradationSettings::Config{
-                              640 * 480,
-                              15,
-                              0,
-                              0,
-                              1,
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0},
-                              {0, 0, 0, 0, 0}}));
+  EXPECT_THAT(config,
+              ::testing::ElementsAre(
+                  BalancedDegradationSettings::Config{
+                      320 * 240,
+                      7,
+                      0,
+                      0,
+                      BalancedDegradationSettings::kNoFpsDiff,
+                      {0, 0, 0, 0, 0},
+                      {0, 0, 0, 0, 0},
+                      {0, 0, 0, 0, 0},
+                      {0, 0, 0, 0, 0},
+                      {0, 0, 0, 0, 0}},
+                  BalancedDegradationSettings::Config{480 * 360,
+                                                      10,
+                                                      0,
+                                                      0,
+                                                      1,
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0}},
+                  BalancedDegradationSettings::Config{640 * 480,
+                                                      15,
+                                                      0,
+                                                      0,
+                                                      1,
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0},
+                                                      {0, 0, 0, 0, 0}}));
 }
 }  // namespace
 
diff --git a/rtc_base/experiments/cpu_speed_experiment.h b/rtc_base/experiments/cpu_speed_experiment.h
index 025c1ea..24ec0c0 100644
--- a/rtc_base/experiments/cpu_speed_experiment.h
+++ b/rtc_base/experiments/cpu_speed_experiment.h
@@ -14,7 +14,6 @@
 #include <vector>
 
 #include "absl/types/optional.h"
-
 #include "rtc_base/experiments/field_trial_parser.h"
 
 namespace webrtc {
diff --git a/rtc_base/experiments/field_trial_list.h b/rtc_base/experiments/field_trial_list.h
index 2619772..63403cc 100644
--- a/rtc_base/experiments/field_trial_list.h
+++ b/rtc_base/experiments/field_trial_list.h
@@ -123,7 +123,7 @@
 struct LambdaTypeTraits : public LambdaTypeTraits<decltype(&T::operator())> {};
 
 template <typename ClassType, typename RetType, typename SourceType>
-struct LambdaTypeTraits<RetType* (ClassType::*)(SourceType*)const> {
+struct LambdaTypeTraits<RetType* (ClassType::*)(SourceType*) const> {
   using ret = RetType;
   using src = SourceType;
 };
diff --git a/rtc_base/experiments/struct_parameters_parser_unittest.cc b/rtc_base/experiments/struct_parameters_parser_unittest.cc
index 2f92b9f..0824bd3 100644
--- a/rtc_base/experiments/struct_parameters_parser_unittest.cc
+++ b/rtc_base/experiments/struct_parameters_parser_unittest.cc
@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "rtc_base/experiments/struct_parameters_parser.h"
+
 #include "rtc_base/gunit.h"
 
 namespace webrtc {
diff --git a/rtc_base/ip_address.cc b/rtc_base/ip_address.cc
index d544b61..9e436e3 100644
--- a/rtc_base/ip_address.cc
+++ b/rtc_base/ip_address.cc
@@ -22,9 +22,8 @@
 #include <netdb.h>
 #endif
 
-#include "rtc_base/ip_address.h"
-
 #include "rtc_base/byte_order.h"
+#include "rtc_base/ip_address.h"
 #include "rtc_base/net_helpers.h"
 #include "rtc_base/string_utils.h"
 
diff --git a/rtc_base/logging.cc b/rtc_base/logging.cc
index 65d5059..61a3c66 100644
--- a/rtc_base/logging.cc
+++ b/rtc_base/logging.cc
@@ -366,9 +366,8 @@
   CFStringRef domain = CFBundleGetIdentifier(CFBundleGetMainBundle());
   if (domain != nullptr) {
     Boolean exists_and_is_valid;
-    Boolean should_log =
-        CFPreferencesGetAppBooleanValue(CFSTR("logToStdErr"), domain,
-                                        &exists_and_is_valid);
+    Boolean should_log = CFPreferencesGetAppBooleanValue(
+        CFSTR("logToStdErr"), domain, &exists_and_is_valid);
     // If the key doesn't exist or is invalid or is false, we will not log to
     // stderr.
     log_to_stderr = exists_and_is_valid && should_log;
diff --git a/rtc_base/network_route.cc b/rtc_base/network_route.cc
index 80d135a..9762dc2 100644
--- a/rtc_base/network_route.cc
+++ b/rtc_base/network_route.cc
@@ -20,8 +20,8 @@
 
 bool NetworkRoute::operator==(const NetworkRoute& other) const {
   return connected == other.connected && local == other.local &&
-      remote == other.remote && packet_overhead == other.packet_overhead &&
-      last_sent_packet_id == other.last_sent_packet_id;
+         remote == other.remote && packet_overhead == other.packet_overhead &&
+         last_sent_packet_id == other.last_sent_packet_id;
 }
 
 }  // namespace rtc
diff --git a/rtc_base/numerics/event_based_exponential_moving_average.h b/rtc_base/numerics/event_based_exponential_moving_average.h
index a59fff7..69f4e61 100644
--- a/rtc_base/numerics/event_based_exponential_moving_average.h
+++ b/rtc_base/numerics/event_based_exponential_moving_average.h
@@ -14,6 +14,7 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
+
 #include "absl/types/optional.h"
 
 namespace rtc {
diff --git a/rtc_base/numerics/safe_minmax.h b/rtc_base/numerics/safe_minmax.h
index 6c41dfd..8356536 100644
--- a/rtc_base/numerics/safe_minmax.h
+++ b/rtc_base/numerics/safe_minmax.h
@@ -325,9 +325,9 @@
   static_assert(IsIntlike<L>::value || std::is_floating_point<L>::value,
                 "The third argument must be integral or floating-point");
   RTC_DCHECK_LE(min, max);
-  return SafeLe(x, min)
-             ? static_cast<R2>(min)
-             : SafeGe(x, max) ? static_cast<R2>(max) : static_cast<R2>(x);
+  return SafeLe(x, min)   ? static_cast<R2>(min)
+         : SafeGe(x, max) ? static_cast<R2>(max)
+                          : static_cast<R2>(x);
 }
 
 }  // namespace rtc
diff --git a/rtc_base/openssl_utility_unittest.cc b/rtc_base/openssl_utility_unittest.cc
index d090524..3302490 100644
--- a/rtc_base/openssl_utility_unittest.cc
+++ b/rtc_base/openssl_utility_unittest.cc
@@ -184,7 +184,6 @@
 // The server is deallocated. This client will have a peer certificate available
 // and is thus suitable for testing VerifyPeerCertMatchesHost.
 SSL* CreateSSLWithPeerCertificate(const unsigned char* cert, size_t cert_len) {
-
   const unsigned char* key_ptr = kFakeSSLPrivateKey;
   EVP_PKEY* key = d2i_PrivateKey(
       EVP_PKEY_EC, nullptr, &key_ptr,
diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc
index 652e4c5..84c9621 100644
--- a/rtc_base/proxy_server.cc
+++ b/rtc_base/proxy_server.cc
@@ -13,6 +13,7 @@
 #include <stddef.h>
 
 #include <memory>
+
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/socket_factory.h"
diff --git a/rtc_base/rate_statistics.h b/rtc_base/rate_statistics.h
index dc8d7f5..e7ce8ad 100644
--- a/rtc_base/rate_statistics.h
+++ b/rtc_base/rate_statistics.h
@@ -73,7 +73,7 @@
 
   struct Bucket {
     explicit Bucket(int64_t timestamp);
-    int64_t sum;  // Sum of all samples in this bucket.
+    int64_t sum;              // Sum of all samples in this bucket.
     int num_samples;          // Number of samples in this bucket.
     const int64_t timestamp;  // Timestamp this bucket corresponds to.
   };
diff --git a/rtc_base/strings/string_format.cc b/rtc_base/strings/string_format.cc
index f92be33..e69fb61 100644
--- a/rtc_base/strings/string_format.cc
+++ b/rtc_base/strings/string_format.cc
@@ -8,10 +8,10 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#include <cstdarg>
-
 #include "rtc_base/strings/string_format.h"
 
+#include <cstdarg>
+
 #include "rtc_base/checks.h"
 
 namespace rtc {
diff --git a/rtc_base/strong_alias_unittest.cc b/rtc_base/strong_alias_unittest.cc
index a87bc4d..711c805 100644
--- a/rtc_base/strong_alias_unittest.cc
+++ b/rtc_base/strong_alias_unittest.cc
@@ -62,8 +62,8 @@
   // Const value getter.
   const FooAlias const_alias(GetExampleValue<TypeParam>(1));
   EXPECT_EQ(GetExampleValue<TypeParam>(1), const_alias.value());
-  static_assert(std::is_const<typename std::remove_reference<decltype(
-                    const_alias.value())>::type>::value,
+  static_assert(std::is_const<typename std::remove_reference<
+                    decltype(const_alias.value())>::type>::value,
                 "Reference returned by const value getter should be const.");
 }
 
diff --git a/rtc_base/synchronization/mutex.h b/rtc_base/synchronization/mutex.h
index 2cf0e67..104f4fd 100644
--- a/rtc_base/synchronization/mutex.h
+++ b/rtc_base/synchronization/mutex.h
@@ -38,9 +38,7 @@
   Mutex(const Mutex&) = delete;
   Mutex& operator=(const Mutex&) = delete;
 
-  void Lock() RTC_EXCLUSIVE_LOCK_FUNCTION() {
-    impl_.Lock();
-  }
+  void Lock() RTC_EXCLUSIVE_LOCK_FUNCTION() { impl_.Lock(); }
   ABSL_MUST_USE_RESULT bool TryLock() RTC_EXCLUSIVE_TRYLOCK_FUNCTION(true) {
     return impl_.TryLock();
   }
@@ -48,9 +46,7 @@
   // Otherwise, may report an error (typically by crashing with a diagnostic),
   // or may return immediately.
   void AssertHeld() const RTC_ASSERT_EXCLUSIVE_LOCK() { impl_.AssertHeld(); }
-  void Unlock() RTC_UNLOCK_FUNCTION() {
-    impl_.Unlock();
-  }
+  void Unlock() RTC_UNLOCK_FUNCTION() { impl_.Unlock(); }
 
  private:
   MutexImpl impl_;
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index d5b467c..cd733db 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -738,11 +738,10 @@
   // thread. The second event ensures that the message is processed.
   Event event_set_by_test_thread;
   Event event_set_by_background_thread;
-  background_thread->PostTask(
-      [&event_set_by_test_thread, &event_set_by_background_thread] {
-        WaitAndSetEvent(&event_set_by_test_thread,
-                        &event_set_by_background_thread);
-      });
+  background_thread->PostTask([&event_set_by_test_thread,
+                               &event_set_by_background_thread] {
+    WaitAndSetEvent(&event_set_by_test_thread, &event_set_by_background_thread);
+  });
   event_set_by_test_thread.Set();
   event_set_by_background_thread.Wait(Event::kForever);
 }
diff --git a/rtc_base/trace_event.h b/rtc_base/trace_event.h
index e9a5c4c..6689bc0 100644
--- a/rtc_base/trace_event.h
+++ b/rtc_base/trace_event.h
@@ -21,13 +21,13 @@
 #endif
 
 // Type values for identifying types in the TraceValue union.
-#define TRACE_VALUE_TYPE_BOOL         (static_cast<unsigned char>(1))
-#define TRACE_VALUE_TYPE_UINT         (static_cast<unsigned char>(2))
-#define TRACE_VALUE_TYPE_INT          (static_cast<unsigned char>(3))
-#define TRACE_VALUE_TYPE_DOUBLE       (static_cast<unsigned char>(4))
-#define TRACE_VALUE_TYPE_POINTER      (static_cast<unsigned char>(5))
-#define TRACE_VALUE_TYPE_STRING       (static_cast<unsigned char>(6))
-#define TRACE_VALUE_TYPE_COPY_STRING  (static_cast<unsigned char>(7))
+#define TRACE_VALUE_TYPE_BOOL (static_cast<unsigned char>(1))
+#define TRACE_VALUE_TYPE_UINT (static_cast<unsigned char>(2))
+#define TRACE_VALUE_TYPE_INT (static_cast<unsigned char>(3))
+#define TRACE_VALUE_TYPE_DOUBLE (static_cast<unsigned char>(4))
+#define TRACE_VALUE_TYPE_POINTER (static_cast<unsigned char>(5))
+#define TRACE_VALUE_TYPE_STRING (static_cast<unsigned char>(6))
+#define TRACE_VALUE_TYPE_COPY_STRING (static_cast<unsigned char>(7))
 
 #if RTC_TRACE_EVENTS_ENABLED
 
@@ -161,7 +161,7 @@
 // By default, const char* argument values are assumed to have long-lived scope
 // and will not be copied. Use this macro to force a const char* to be copied.
 #define TRACE_STR_COPY(str) \
-    webrtc::trace_event_internal::TraceStringWithCopy(str)
+  webrtc::trace_event_internal::TraceStringWithCopy(str)
 
 // This will mark the trace event as disabled by default. The user will need
 // to explicitly enable the event.
@@ -170,7 +170,7 @@
 // By default, uint64 ID argument values are not mangled with the Process ID in
 // TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
 #define TRACE_ID_MANGLE(id) \
-    webrtc::trace_event_internal::TraceID::ForceMangle(id)
+  webrtc::trace_event_internal::TraceID::ForceMangle(id)
 
 // Records a pair of begin and end events called "name" for the current
 // scope, with 0, 1 or 2 associated arguments. If the category is not
@@ -178,126 +178,126 @@
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 #define TRACE_EVENT0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name)
+  INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name)
 #define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, arg1_name, arg1_val)
 #define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
+  INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, arg1_name, arg1_val,         \
+                                  arg2_name, arg2_val)
 
 // Records a single event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
 // does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
-#define TRACE_EVENT_INSTANT0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
-        category, name, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
-        category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
-        category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_INSTANT0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
-        category, name, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_INSTANT0(category, name)                          \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category, name, \
+                           TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val)     \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category, name, \
+                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, arg2_name, \
+                             arg2_val)                                       \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category, name,        \
+                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,       \
+                           arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_INSTANT0(category, name)                     \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category, name, \
+                           TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
-        category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category, name,  \
+                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
 #define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, \
-        category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
+                                  arg2_name, arg2_val)                 \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_INSTANT, category, name,  \
+                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
+                           arg2_name, arg2_val)
 
 // Records a single BEGIN event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
 // does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
-#define TRACE_EVENT_BEGIN0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
-        category, name, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
-        category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
-        category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_BEGIN0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
-        category, name, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_BEGIN0(category, name)                          \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category, name, \
+                           TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val)     \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category, name, \
+                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, arg2_name, \
+                           arg2_val)                                       \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category, name,        \
+                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,     \
+                           arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_BEGIN0(category, name)                     \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category, name, \
+                           TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
-        category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
-        category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category, name,  \
+                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val,   \
+                                arg2_name, arg2_val)                   \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, category, name,    \
+                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
+                           arg2_name, arg2_val)
 
 // Records a single END event for "name" immediately. If the category
 // is not enabled, then this does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
-#define TRACE_EVENT_END0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
-        category, name, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
-        category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
-        category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_END0(category, name) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
-        category, name, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_END0(category, name)                          \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category, name, \
+                           TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_END1(category, name, arg1_name, arg1_val)     \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category, name, \
+                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
+#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, arg2_name, \
+                         arg2_val)                                       \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category, name,        \
+                           TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val,   \
+                           arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_END0(category, name)                     \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category, name, \
+                           TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
-        category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
-        category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
-        arg2_name, arg2_val)
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category, name,  \
+                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, arg2_name, \
+                              arg2_val)                                       \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, category, name,             \
+                           TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val,        \
+                           arg2_name, arg2_val)
 
 // Records the value of a counter called "name" immediately. Value
 // must be representable as a 32 bit integer.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
-#define TRACE_COUNTER1(category, name, value) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, TRACE_EVENT_FLAG_NONE, \
-        "value", static_cast<int>(value))
-#define TRACE_COPY_COUNTER1(category, name, value) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, TRACE_EVENT_FLAG_COPY, \
-        "value", static_cast<int>(value))
+#define TRACE_COUNTER1(category, name, value)                         \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                           TRACE_EVENT_FLAG_NONE, "value",            \
+                           static_cast<int>(value))
+#define TRACE_COPY_COUNTER1(category, name, value)                    \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                           TRACE_EVENT_FLAG_COPY, "value",            \
+                           static_cast<int>(value))
 
 // Records the values of a multi-parted counter called "name" immediately.
 // The UI will treat value1 and value2 as parts of a whole, displaying their
 // values as a stacked-bar chart.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
-#define TRACE_COUNTER2(category, name, value1_name, value1_val, \
-        value2_name, value2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, TRACE_EVENT_FLAG_NONE, \
-        value1_name, static_cast<int>(value1_val), \
-        value2_name, static_cast<int>(value2_val))
-#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \
-        value2_name, value2_val) \
-    INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, TRACE_EVENT_FLAG_COPY, \
-        value1_name, static_cast<int>(value1_val), \
-        value2_name, static_cast<int>(value2_val))
+#define TRACE_COUNTER2(category, name, value1_name, value1_val, value2_name, \
+                       value2_val)                                           \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category, name,        \
+                           TRACE_EVENT_FLAG_NONE, value1_name,               \
+                           static_cast<int>(value1_val), value2_name,        \
+                           static_cast<int>(value2_val))
+#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val,  \
+                            value2_name, value2_val)                  \
+  INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                           TRACE_EVENT_FLAG_COPY, value1_name,        \
+                           static_cast<int>(value1_val), value2_name, \
+                           static_cast<int>(value2_val))
 
 // Records the value of a counter called "name" immediately. Value
 // must be representable as a 32 bit integer.
@@ -307,14 +307,14 @@
 //   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
 //   will be xored with a hash of the process ID so that the same pointer on
 //   two different processes will not collide.
-#define TRACE_COUNTER_ID1(category, name, id, value) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, \
-        "value", static_cast<int>(value))
-#define TRACE_COPY_COUNTER_ID1(category, name, id, value) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        "value", static_cast<int>(value))
+#define TRACE_COUNTER_ID1(category, name, id, value)                          \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                                   id, TRACE_EVENT_FLAG_NONE, "value",        \
+                                   static_cast<int>(value))
+#define TRACE_COPY_COUNTER_ID1(category, name, id, value)                     \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                                   id, TRACE_EVENT_FLAG_COPY, "value",        \
+                                   static_cast<int>(value))
 
 // Records the values of a multi-parted counter called "name" immediately.
 // The UI will treat value1 and value2 as parts of a whole, displaying their
@@ -325,19 +325,18 @@
 //   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
 //   will be xored with a hash of the process ID so that the same pointer on
 //   two different processes will not collide.
-#define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
-        value2_name, value2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, \
-        value1_name, static_cast<int>(value1_val), \
-        value2_name, static_cast<int>(value2_val))
-#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
-        value2_name, value2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        value1_name, static_cast<int>(value1_val), \
-        value2_name, static_cast<int>(value2_val))
-
+#define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val,        \
+                          value2_name, value2_val)                            \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                                   id, TRACE_EVENT_FLAG_NONE, value1_name,    \
+                                   static_cast<int>(value1_val), value2_name, \
+                                   static_cast<int>(value2_val))
+#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val,   \
+                               value2_name, value2_val)                       \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, category, name, \
+                                   id, TRACE_EVENT_FLAG_COPY, value1_name,    \
+                                   static_cast<int>(value1_val), value2_name, \
+                                   static_cast<int>(value2_val))
 
 // Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
@@ -356,78 +355,80 @@
 // drawn on the thread defined in the ASYNC_BEGIN event), but all events in that
 // operation must use the same `name` and `id`. Each event can have its own
 // args.
-#define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_ASYNC_BEGIN0(category, name, id)                        \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, category, \
+                                   name, id, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val)      \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, category,    \
+                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+                                   arg1_val)
+#define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val,      \
+                                 arg2_name, arg2_val)                          \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, category,    \
+                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+                                   arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id)                   \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, category, \
+                                   name, id, TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val)
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, category,    \
+                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+                                   arg1_val)
 #define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
+                                      arg2_name, arg2_val)                     \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_BEGIN, category,    \
+                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+                                   arg1_val, arg2_name, arg2_val)
 
 // Records a single ASYNC_STEP event for `step` immediately. If the category
 // is not enabled, then this does nothing. The `name` and `id` must match the
 // ASYNC_BEGIN event above. The `step` param identifies this step within the
 // async event. This should be called at the beginning of the next phase of an
 // asynchronous operation.
-#define TRACE_EVENT_ASYNC_STEP0(category, name, id, step) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, "step", step)
-#define TRACE_EVENT_ASYNC_STEP1(category, name, id, step, \
-                                      arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, "step", step, \
-        arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_ASYNC_STEP0(category, name, id, step) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, "step", step)
-#define TRACE_EVENT_COPY_ASYNC_STEP1(category, name, id, step, \
-        arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, "step", step, \
-        arg1_name, arg1_val)
+#define TRACE_EVENT_ASYNC_STEP0(category, name, id, step)                   \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, category,  \
+                                   name, id, TRACE_EVENT_FLAG_NONE, "step", \
+                                   step)
+#define TRACE_EVENT_ASYNC_STEP1(category, name, id, step, arg1_name, arg1_val) \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, category,     \
+                                   name, id, TRACE_EVENT_FLAG_NONE, "step",    \
+                                   step, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_ASYNC_STEP0(category, name, id, step)              \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, category,  \
+                                   name, id, TRACE_EVENT_FLAG_COPY, "step", \
+                                   step)
+#define TRACE_EVENT_COPY_ASYNC_STEP1(category, name, id, step, arg1_name,   \
+                                     arg1_val)                              \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP, category,  \
+                                   name, id, TRACE_EVENT_FLAG_COPY, "step", \
+                                   step, arg1_name, arg1_val)
 
 // Records a single ASYNC_END event for "name" immediately. If the category
 // is not enabled, then this does nothing.
-#define TRACE_EVENT_ASYNC_END0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-        category, name, id, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-        category, name, id, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
-
+#define TRACE_EVENT_ASYNC_END0(category, name, id)                        \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, category, \
+                                   name, id, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val)        \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, category,      \
+                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+                                   arg1_val)
+#define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val,        \
+                               arg2_name, arg2_val)                            \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, category,      \
+                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+                                   arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id)                   \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, category, \
+                                   name, id, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val)   \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, category,      \
+                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+                                   arg1_val)
+#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val,   \
+                                    arg2_name, arg2_val)                       \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_END, category,      \
+                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+                                   arg1_val, arg2_name, arg2_val)
 
 // Records a single FLOW_BEGIN event called "name" immediately, with 0, 1 or 2
 // associated arguments. If the category is not enabled, then this
@@ -448,78 +449,80 @@
 // macros. When the operation completes, call FLOW_END. An async operation can
 // span threads and processes, but all events in that operation must use the
 // same `name` and `id`. Each event can have its own args.
-#define TRACE_EVENT_FLOW_BEGIN0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_FLOW_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_FLOW_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_FLOW_BEGIN0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_FLOW_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_FLOW_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_FLOW_BEGIN0(category, name, id)                        \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, category, \
+                                   name, id, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_FLOW_BEGIN1(category, name, id, arg1_name, arg1_val)       \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, category,     \
+                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+                                   arg1_val)
+#define TRACE_EVENT_FLOW_BEGIN2(category, name, id, arg1_name, arg1_val,       \
+                                arg2_name, arg2_val)                           \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, category,     \
+                                   name, id, TRACE_EVENT_FLAG_NONE, arg1_name, \
+                                   arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_FLOW_BEGIN0(category, name, id)                   \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, category, \
+                                   name, id, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_FLOW_BEGIN1(category, name, id, arg1_name, arg1_val)  \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, category,     \
+                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+                                   arg1_val)
+#define TRACE_EVENT_COPY_FLOW_BEGIN2(category, name, id, arg1_name, arg1_val,  \
+                                     arg2_name, arg2_val)                      \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_BEGIN, category,     \
+                                   name, id, TRACE_EVENT_FLAG_COPY, arg1_name, \
+                                   arg1_val, arg2_name, arg2_val)
 
 // Records a single FLOW_STEP event for `step` immediately. If the category
 // is not enabled, then this does nothing. The `name` and `id` must match the
 // FLOW_BEGIN event above. The `step` param identifies this step within the
 // async event. This should be called at the beginning of the next phase of an
 // asynchronous operation.
-#define TRACE_EVENT_FLOW_STEP0(category, name, id, step) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, "step", step)
-#define TRACE_EVENT_FLOW_STEP1(category, name, id, step, \
-        arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, "step", step, \
-        arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_FLOW_STEP0(category, name, id, step) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, "step", step)
-#define TRACE_EVENT_COPY_FLOW_STEP1(category, name, id, step, \
-        arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, "step", step, \
-        arg1_name, arg1_val)
+#define TRACE_EVENT_FLOW_STEP0(category, name, id, step)                    \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, category,   \
+                                   name, id, TRACE_EVENT_FLAG_NONE, "step", \
+                                   step)
+#define TRACE_EVENT_FLOW_STEP1(category, name, id, step, arg1_name, arg1_val) \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, category,     \
+                                   name, id, TRACE_EVENT_FLAG_NONE, "step",   \
+                                   step, arg1_name, arg1_val)
+#define TRACE_EVENT_COPY_FLOW_STEP0(category, name, id, step)               \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, category,   \
+                                   name, id, TRACE_EVENT_FLAG_COPY, "step", \
+                                   step)
+#define TRACE_EVENT_COPY_FLOW_STEP1(category, name, id, step, arg1_name,    \
+                                    arg1_val)                               \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_STEP, category,   \
+                                   name, id, TRACE_EVENT_FLAG_COPY, "step", \
+                                   step, arg1_name, arg1_val)
 
 // Records a single FLOW_END event for "name" immediately. If the category
 // is not enabled, then this does nothing.
-#define TRACE_EVENT_FLOW_END0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
-        category, name, id, TRACE_EVENT_FLAG_NONE)
-#define TRACE_EVENT_FLOW_END1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
-#define TRACE_EVENT_FLOW_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
-        category, name, id, TRACE_EVENT_FLAG_NONE, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
-#define TRACE_EVENT_COPY_FLOW_END0(category, name, id) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
-        category, name, id, TRACE_EVENT_FLAG_COPY)
-#define TRACE_EVENT_COPY_FLOW_END1(category, name, id, arg1_name, arg1_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val)
-#define TRACE_EVENT_COPY_FLOW_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) \
-    INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, \
-        category, name, id, TRACE_EVENT_FLAG_COPY, \
-        arg1_name, arg1_val, arg2_name, arg2_val)
-
+#define TRACE_EVENT_FLOW_END0(category, name, id)                              \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category, name, \
+                                   id, TRACE_EVENT_FLAG_NONE)
+#define TRACE_EVENT_FLOW_END1(category, name, id, arg1_name, arg1_val)         \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category, name, \
+                                   id, TRACE_EVENT_FLAG_NONE, arg1_name,       \
+                                   arg1_val)
+#define TRACE_EVENT_FLOW_END2(category, name, id, arg1_name, arg1_val,         \
+                              arg2_name, arg2_val)                             \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category, name, \
+                                   id, TRACE_EVENT_FLAG_NONE, arg1_name,       \
+                                   arg1_val, arg2_name, arg2_val)
+#define TRACE_EVENT_COPY_FLOW_END0(category, name, id)                         \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category, name, \
+                                   id, TRACE_EVENT_FLAG_COPY)
+#define TRACE_EVENT_COPY_FLOW_END1(category, name, id, arg1_name, arg1_val)    \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category, name, \
+                                   id, TRACE_EVENT_FLAG_COPY, arg1_name,       \
+                                   arg1_val)
+#define TRACE_EVENT_COPY_FLOW_END2(category, name, id, arg1_name, arg1_val,    \
+                                   arg2_name, arg2_val)                        \
+  INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FLOW_END, category, name, \
+                                   id, TRACE_EVENT_FLAG_COPY, arg1_name,       \
+                                   arg1_val, arg2_name, arg2_val)
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation specific tracing API definitions.
@@ -535,7 +538,7 @@
 // const unsigned char*
 //     TRACE_EVENT_API_GET_CATEGORY_ENABLED(const char* category_name)
 #define TRACE_EVENT_API_GET_CATEGORY_ENABLED \
-    webrtc::EventTracer::GetCategoryEnabled
+  webrtc::EventTracer::GetCategoryEnabled
 
 // Add a trace event to the platform tracing system.
 // void TRACE_EVENT_API_ADD_TRACE_EVENT(
@@ -555,12 +558,10 @@
 // Implementation detail: trace event macros create temporary variables
 // to keep instrumentation overhead low. These macros give each temporary
 // variable a unique name based on the line number to prevent name collissions.
-#define INTERNAL_TRACE_EVENT_UID3(a,b) \
-    trace_event_unique_##a##b
-#define INTERNAL_TRACE_EVENT_UID2(a,b) \
-    INTERNAL_TRACE_EVENT_UID3(a,b)
+#define INTERNAL_TRACE_EVENT_UID3(a, b) trace_event_unique_##a##b
+#define INTERNAL_TRACE_EVENT_UID2(a, b) INTERNAL_TRACE_EVENT_UID3(a, b)
 #define INTERNAL_TRACE_EVENT_UID(name_prefix) \
-    INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
+  INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
 
 #if WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS
 #define INTERNAL_TRACE_EVENT_INFO_TYPE const unsigned char*
@@ -569,55 +570,53 @@
 #endif  // WEBRTC_NON_STATIC_TRACE_EVENT_HANDLERS
 
 // Implementation detail: internal macro to create static category.
-#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category) \
-    INTERNAL_TRACE_EVENT_INFO_TYPE INTERNAL_TRACE_EVENT_UID(catstatic) = \
-        TRACE_EVENT_API_GET_CATEGORY_ENABLED(category);
+#define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category)               \
+  INTERNAL_TRACE_EVENT_INFO_TYPE INTERNAL_TRACE_EVENT_UID(catstatic) = \
+      TRACE_EVENT_API_GET_CATEGORY_ENABLED(category);
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
-#define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...) \
-    do { \
-      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
-      if (*INTERNAL_TRACE_EVENT_UID(catstatic)) { \
-        webrtc::trace_event_internal::AddTraceEvent(          \
-            phase, INTERNAL_TRACE_EVENT_UID(catstatic), name, \
-            webrtc::trace_event_internal::kNoEventId, flags, ##__VA_ARGS__); \
-      } \
-    } while (0)
+#define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...)        \
+  do {                                                                     \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category);                      \
+    if (*INTERNAL_TRACE_EVENT_UID(catstatic)) {                            \
+      webrtc::trace_event_internal::AddTraceEvent(                         \
+          phase, INTERNAL_TRACE_EVENT_UID(catstatic), name,                \
+          webrtc::trace_event_internal::kNoEventId, flags, ##__VA_ARGS__); \
+    }                                                                      \
+  } while (0)
 
 // Implementation detail: internal macro to create static category and add begin
 // event if the category is enabled. Also adds the end event when the scope
 // ends.
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, ...) \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
-    webrtc::trace_event_internal::TraceEndOnScopeClose  \
-        INTERNAL_TRACE_EVENT_UID(profileScope); \
-    if (*INTERNAL_TRACE_EVENT_UID(catstatic)) { \
-      webrtc::trace_event_internal::AddTraceEvent(      \
-          TRACE_EVENT_PHASE_BEGIN, \
-          INTERNAL_TRACE_EVENT_UID(catstatic), \
-          name, webrtc::trace_event_internal::kNoEventId,       \
-          TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
-      INTERNAL_TRACE_EVENT_UID(profileScope).Initialize( \
-          INTERNAL_TRACE_EVENT_UID(catstatic), name); \
-    }
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, ...)                   \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category);                            \
+  webrtc::trace_event_internal::TraceEndOnScopeClose INTERNAL_TRACE_EVENT_UID( \
+      profileScope);                                                           \
+  if (*INTERNAL_TRACE_EVENT_UID(catstatic)) {                                  \
+    webrtc::trace_event_internal::AddTraceEvent(                               \
+        TRACE_EVENT_PHASE_BEGIN, INTERNAL_TRACE_EVENT_UID(catstatic), name,    \
+        webrtc::trace_event_internal::kNoEventId, TRACE_EVENT_FLAG_NONE,       \
+        ##__VA_ARGS__);                                                        \
+    INTERNAL_TRACE_EVENT_UID(profileScope)                                     \
+        .Initialize(INTERNAL_TRACE_EVENT_UID(catstatic), name);                \
+  }
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category, name, id, flags, \
-                                         ...) \
-    do { \
-      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
-      if (*INTERNAL_TRACE_EVENT_UID(catstatic)) { \
-        unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
-        webrtc::trace_event_internal::TraceID trace_event_trace_id( \
-            id, &trace_event_flags); \
-        webrtc::trace_event_internal::AddTraceEvent( \
-            phase, INTERNAL_TRACE_EVENT_UID(catstatic), \
-            name, trace_event_trace_id.data(), trace_event_flags, \
-            ##__VA_ARGS__); \
-      } \
-    } while (0)
+                                         ...)                              \
+  do {                                                                     \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category);                      \
+    if (*INTERNAL_TRACE_EVENT_UID(catstatic)) {                            \
+      unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID;   \
+      webrtc::trace_event_internal::TraceID trace_event_trace_id(          \
+          id, &trace_event_flags);                                         \
+      webrtc::trace_event_internal::AddTraceEvent(                         \
+          phase, INTERNAL_TRACE_EVENT_UID(catstatic), name,                \
+          trace_event_trace_id.data(), trace_event_flags, ##__VA_ARGS__);  \
+    }                                                                      \
+  } while (0)
 
 // Notes regarding the following definitions:
 // New values can be added and propagated to third party libraries, but existing
@@ -625,23 +624,23 @@
 // definitions.
 
 // Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
-#define TRACE_EVENT_PHASE_BEGIN    ('B')
-#define TRACE_EVENT_PHASE_END      ('E')
-#define TRACE_EVENT_PHASE_INSTANT  ('I')
+#define TRACE_EVENT_PHASE_BEGIN ('B')
+#define TRACE_EVENT_PHASE_END ('E')
+#define TRACE_EVENT_PHASE_INSTANT ('I')
 #define TRACE_EVENT_PHASE_ASYNC_BEGIN ('S')
-#define TRACE_EVENT_PHASE_ASYNC_STEP  ('T')
-#define TRACE_EVENT_PHASE_ASYNC_END   ('F')
+#define TRACE_EVENT_PHASE_ASYNC_STEP ('T')
+#define TRACE_EVENT_PHASE_ASYNC_END ('F')
 #define TRACE_EVENT_PHASE_FLOW_BEGIN ('s')
-#define TRACE_EVENT_PHASE_FLOW_STEP  ('t')
-#define TRACE_EVENT_PHASE_FLOW_END   ('f')
+#define TRACE_EVENT_PHASE_FLOW_STEP ('t')
+#define TRACE_EVENT_PHASE_FLOW_END ('f')
 #define TRACE_EVENT_PHASE_METADATA ('M')
-#define TRACE_EVENT_PHASE_COUNTER  ('C')
+#define TRACE_EVENT_PHASE_COUNTER ('C')
 
 // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
-#define TRACE_EVENT_FLAG_NONE        (static_cast<unsigned char>(0))
-#define TRACE_EVENT_FLAG_COPY        (static_cast<unsigned char>(1 << 0))
-#define TRACE_EVENT_FLAG_HAS_ID      (static_cast<unsigned char>(1 << 1))
-#define TRACE_EVENT_FLAG_MANGLE_ID   (static_cast<unsigned char>(1 << 2))
+#define TRACE_EVENT_FLAG_NONE (static_cast<unsigned char>(0))
+#define TRACE_EVENT_FLAG_COPY (static_cast<unsigned char>(1 << 0))
+#define TRACE_EVENT_FLAG_HAS_ID (static_cast<unsigned char>(1 << 1))
+#define TRACE_EVENT_FLAG_MANGLE_ID (static_cast<unsigned char>(1 << 2))
 
 namespace webrtc {
 namespace trace_event_internal {
@@ -657,57 +656,71 @@
 class TraceID {
  public:
   class ForceMangle {
-    public:
-     explicit ForceMangle(unsigned long long id) : data_(id) {}
-     explicit ForceMangle(unsigned long id) : data_(id) {}
-     explicit ForceMangle(unsigned int id) : data_(id) {}
-     explicit ForceMangle(unsigned short id) : data_(id) {}
-     explicit ForceMangle(unsigned char id) : data_(id) {}
-     explicit ForceMangle(long long id)
-         : data_(static_cast<unsigned long long>(id)) {}
-     explicit ForceMangle(long id)
-         : data_(static_cast<unsigned long long>(id)) {}
-     explicit ForceMangle(int id)
-         : data_(static_cast<unsigned long long>(id)) {}
-     explicit ForceMangle(short id)
-         : data_(static_cast<unsigned long long>(id)) {}
-     explicit ForceMangle(signed char id)
-         : data_(static_cast<unsigned long long>(id)) {}
+   public:
+    explicit ForceMangle(unsigned long long id) : data_(id) {}
+    explicit ForceMangle(unsigned long id) : data_(id) {}
+    explicit ForceMangle(unsigned int id) : data_(id) {}
+    explicit ForceMangle(unsigned short id) : data_(id) {}
+    explicit ForceMangle(unsigned char id) : data_(id) {}
+    explicit ForceMangle(long long id)
+        : data_(static_cast<unsigned long long>(id)) {}
+    explicit ForceMangle(long id)
+        : data_(static_cast<unsigned long long>(id)) {}
+    explicit ForceMangle(int id) : data_(static_cast<unsigned long long>(id)) {}
+    explicit ForceMangle(short id)
+        : data_(static_cast<unsigned long long>(id)) {}
+    explicit ForceMangle(signed char id)
+        : data_(static_cast<unsigned long long>(id)) {}
 
-     unsigned long long data() const { return data_; }
+    unsigned long long data() const { return data_; }
 
-    private:
-     unsigned long long data_;
+   private:
+    unsigned long long data_;
   };
 
   explicit TraceID(const void* id, unsigned char* flags)
-      : data_(static_cast<unsigned long long>(
-              reinterpret_cast<uintptr_t>(id))) {
+      : data_(
+            static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(id))) {
     *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
   }
   explicit TraceID(ForceMangle id, unsigned char* flags) : data_(id.data()) {
     *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
   }
-  explicit TraceID(unsigned long long id, unsigned char* flags)
-      : data_(id) { (void)flags; }
-  explicit TraceID(unsigned long id, unsigned char* flags)
-      : data_(id) { (void)flags; }
-  explicit TraceID(unsigned int id, unsigned char* flags)
-      : data_(id) { (void)flags; }
-  explicit TraceID(unsigned short id, unsigned char* flags)
-      : data_(id) { (void)flags; }
-  explicit TraceID(unsigned char id, unsigned char* flags)
-      : data_(id) { (void)flags; }
+  explicit TraceID(unsigned long long id, unsigned char* flags) : data_(id) {
+    (void)flags;
+  }
+  explicit TraceID(unsigned long id, unsigned char* flags) : data_(id) {
+    (void)flags;
+  }
+  explicit TraceID(unsigned int id, unsigned char* flags) : data_(id) {
+    (void)flags;
+  }
+  explicit TraceID(unsigned short id, unsigned char* flags) : data_(id) {
+    (void)flags;
+  }
+  explicit TraceID(unsigned char id, unsigned char* flags) : data_(id) {
+    (void)flags;
+  }
   explicit TraceID(long long id, unsigned char* flags)
-      : data_(static_cast<unsigned long long>(id)) { (void)flags; }
+      : data_(static_cast<unsigned long long>(id)) {
+    (void)flags;
+  }
   explicit TraceID(long id, unsigned char* flags)
-      : data_(static_cast<unsigned long long>(id)) { (void)flags; }
+      : data_(static_cast<unsigned long long>(id)) {
+    (void)flags;
+  }
   explicit TraceID(int id, unsigned char* flags)
-      : data_(static_cast<unsigned long long>(id)) { (void)flags; }
+      : data_(static_cast<unsigned long long>(id)) {
+    (void)flags;
+  }
   explicit TraceID(short id, unsigned char* flags)
-      : data_(static_cast<unsigned long long>(id)) { (void)flags; }
+      : data_(static_cast<unsigned long long>(id)) {
+    (void)flags;
+  }
   explicit TraceID(signed char id, unsigned char* flags)
-      : data_(static_cast<unsigned long long>(id)) { (void)flags; }
+      : data_(static_cast<unsigned long long>(id)) {
+    (void)flags;
+  }
 
   unsigned long long data() const { return data_; }
 
@@ -729,7 +742,8 @@
 class TraceStringWithCopy {
  public:
   explicit TraceStringWithCopy(const char* str) : str_(str) {}
-  operator const char* () const { return str_; }
+  operator const char*() const { return str_; }
+
  private:
   const char* str_;
 };
@@ -737,26 +751,22 @@
 // Define SetTraceValue for each allowed type. It stores the type and
 // value in the return arguments. This allows this API to avoid declaring any
 // structures so that it is portable to third_party libraries.
-#define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, \
-                                         union_member, \
-                                         value_type_id) \
-    static inline void SetTraceValue(actual_type arg, \
-                                     unsigned char* type, \
-                                     unsigned long long* value) { \
-      TraceValueUnion type_value; \
-      type_value.union_member = arg; \
-      *type = value_type_id; \
-      *value = type_value.as_uint; \
-    }
+#define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, union_member,      \
+                                         value_type_id)                  \
+  static inline void SetTraceValue(actual_type arg, unsigned char* type, \
+                                   unsigned long long* value) {          \
+    TraceValueUnion type_value;                                          \
+    type_value.union_member = arg;                                       \
+    *type = value_type_id;                                               \
+    *value = type_value.as_uint;                                         \
+  }
 // Simpler form for int types that can be safely casted.
-#define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, \
-                                             value_type_id) \
-    static inline void SetTraceValue(actual_type arg, \
-                                     unsigned char* type, \
-                                     unsigned long long* value) { \
-      *type = value_type_id; \
-      *value = static_cast<unsigned long long>(arg); \
-    }
+#define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, value_type_id) \
+  static inline void SetTraceValue(actual_type arg, unsigned char* type, \
+                                   unsigned long long* value) {          \
+    *type = value_type_id;                                               \
+    *value = static_cast<unsigned long long>(arg);                       \
+  }
 
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned long long, TRACE_VALUE_TYPE_UINT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned long, TRACE_VALUE_TYPE_UINT)
@@ -770,11 +780,14 @@
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
 INTERNAL_DECLARE_SET_TRACE_VALUE(bool, as_bool, TRACE_VALUE_TYPE_BOOL)
 INTERNAL_DECLARE_SET_TRACE_VALUE(double, as_double, TRACE_VALUE_TYPE_DOUBLE)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer,
+INTERNAL_DECLARE_SET_TRACE_VALUE(const void*,
+                                 as_pointer,
                                  TRACE_VALUE_TYPE_POINTER)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string,
+INTERNAL_DECLARE_SET_TRACE_VALUE(const char*,
+                                 as_string,
                                  TRACE_VALUE_TYPE_STRING)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, as_string,
+INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&,
+                                 as_string,
                                  TRACE_VALUE_TYPE_COPY_STRING)
 
 #undef INTERNAL_DECLARE_SET_TRACE_VALUE
@@ -797,53 +810,49 @@
 // these procedures.
 
 static inline void AddTraceEvent(char phase,
-                                const unsigned char* category_enabled,
-                                const char* name,
-                                unsigned long long id,
-                                unsigned char flags) {
+                                 const unsigned char* category_enabled,
+                                 const char* name,
+                                 unsigned long long id,
+                                 unsigned char flags) {
   TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_enabled, name, id,
                                   kZeroNumArgs, nullptr, nullptr, nullptr,
                                   flags);
 }
 
-template<class ARG1_TYPE>
+template <class ARG1_TYPE>
 static inline void AddTraceEvent(char phase,
-                                const unsigned char* category_enabled,
-                                const char* name,
-                                unsigned long long id,
-                                unsigned char flags,
-                                const char* arg1_name,
-                                const ARG1_TYPE& arg1_val) {
+                                 const unsigned char* category_enabled,
+                                 const char* name,
+                                 unsigned long long id,
+                                 unsigned char flags,
+                                 const char* arg1_name,
+                                 const ARG1_TYPE& arg1_val) {
   const int num_args = 1;
   unsigned char arg_types[1];
   unsigned long long arg_values[1];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
-  TRACE_EVENT_API_ADD_TRACE_EVENT(
-      phase, category_enabled, name, id,
-      num_args, &arg1_name, arg_types, arg_values,
-      flags);
+  TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_enabled, name, id, num_args,
+                                  &arg1_name, arg_types, arg_values, flags);
 }
 
-template<class ARG1_TYPE, class ARG2_TYPE>
+template <class ARG1_TYPE, class ARG2_TYPE>
 static inline void AddTraceEvent(char phase,
-                                const unsigned char* category_enabled,
-                                const char* name,
-                                unsigned long long id,
-                                unsigned char flags,
-                                const char* arg1_name,
-                                const ARG1_TYPE& arg1_val,
-                                const char* arg2_name,
-                                const ARG2_TYPE& arg2_val) {
+                                 const unsigned char* category_enabled,
+                                 const char* name,
+                                 unsigned long long id,
+                                 unsigned char flags,
+                                 const char* arg1_name,
+                                 const ARG1_TYPE& arg1_val,
+                                 const char* arg2_name,
+                                 const ARG2_TYPE& arg2_val) {
   const int num_args = 2;
-  const char* arg_names[2] = { arg1_name, arg2_name };
+  const char* arg_names[2] = {arg1_name, arg2_name};
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
-  TRACE_EVENT_API_ADD_TRACE_EVENT(
-      phase, category_enabled, name, id,
-      num_args, arg_names, arg_types, arg_values,
-      flags);
+  TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_enabled, name, id, num_args,
+                                  arg_names, arg_types, arg_values, flags);
 }
 
 // Used by TRACE_EVENTx macro. Do not use directly.
@@ -856,8 +865,7 @@
       AddEventIfEnabled();
   }
 
-  void Initialize(const unsigned char* category_enabled,
-                  const char* name) {
+  void Initialize(const unsigned char* category_enabled, const char* name) {
     data_.category_enabled = category_enabled;
     data_.name = name;
     p_data_ = &data_;
@@ -896,7 +904,9 @@
 // This section defines no-op alternatives to the tracing macros when
 // RTC_DISABLE_TRACE_EVENTS is defined.
 
-#define RTC_NOOP() do {} while (0)
+#define RTC_NOOP() \
+  do {             \
+  } while (0)
 
 #define TRACE_STR_COPY(str) RTC_NOOP()
 
@@ -907,111 +917,131 @@
 #define TRACE_EVENT0(category, name) RTC_NOOP()
 #define TRACE_EVENT1(category, name, arg1_name, arg1_val) RTC_NOOP()
 #define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, arg2_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 
 #define TRACE_EVENT_INSTANT0(category, name) RTC_NOOP()
 #define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) RTC_NOOP()
 
-#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, arg2_name, \
+                             arg2_val)                                       \
+  RTC_NOOP()
 
 #define TRACE_EVENT_COPY_INSTANT0(category, name) RTC_NOOP()
 #define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                  arg2_name, arg2_val)                 \
+  RTC_NOOP()
 
 #define TRACE_EVENT_BEGIN0(category, name) RTC_NOOP()
 #define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) RTC_NOOP()
-#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, arg2_name, \
+                           arg2_val)                                       \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_BEGIN0(category, name) RTC_NOOP()
 #define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) RTC_NOOP()
 #define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                arg2_name, arg2_val)                 \
+  RTC_NOOP()
 
 #define TRACE_EVENT_END0(category, name) RTC_NOOP()
 #define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) RTC_NOOP()
-#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, arg2_name, \
+                         arg2_val)                                       \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_END0(category, name) RTC_NOOP()
 #define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) RTC_NOOP()
-#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, arg2_name, \
+                              arg2_val)                                       \
+  RTC_NOOP()
 
 #define TRACE_COUNTER1(category, name, value) RTC_NOOP()
 #define TRACE_COPY_COUNTER1(category, name, value) RTC_NOOP()
 
-#define TRACE_COUNTER2(category, name, value1_name, value1_val, \
-        value2_name, value2_val) RTC_NOOP()
+#define TRACE_COUNTER2(category, name, value1_name, value1_val, value2_name, \
+                       value2_val)                                           \
+  RTC_NOOP()
 #define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \
-        value2_name, value2_val) RTC_NOOP()
+                            value2_name, value2_val)                 \
+  RTC_NOOP()
 
 #define TRACE_COUNTER_ID1(category, name, id, value) RTC_NOOP()
 #define TRACE_COPY_COUNTER_ID1(category, name, id, value) RTC_NOOP()
 
 #define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
-        value2_name, value2_val) RTC_NOOP()
+                          value2_name, value2_val)                     \
+  RTC_NOOP()
 #define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
-        value2_name, value2_val) RTC_NOOP()
+                               value2_name, value2_val)                     \
+  RTC_NOOP()
 
 #define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                 arg2_name, arg2_val)                     \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                      arg2_name, arg2_val)                     \
+  RTC_NOOP()
 
 #define TRACE_EVENT_ASYNC_STEP0(category, name, id, step) RTC_NOOP()
-#define TRACE_EVENT_ASYNC_STEP1(category, name, id, step, \
-                                      arg1_name, arg1_val) RTC_NOOP()
+#define TRACE_EVENT_ASYNC_STEP1(category, name, id, step, arg1_name, arg1_val) \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_STEP0(category, name, id, step) RTC_NOOP()
-#define TRACE_EVENT_COPY_ASYNC_STEP1(category, name, id, step, \
-        arg1_name, arg1_val) RTC_NOOP()
+#define TRACE_EVENT_COPY_ASYNC_STEP1(category, name, id, step, arg1_name, \
+                                     arg1_val)                            \
+  RTC_NOOP()
 
 #define TRACE_EVENT_ASYNC_END0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                               arg2_name, arg2_val)                     \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                    arg2_name, arg2_val)                     \
+  RTC_NOOP()
 
 #define TRACE_EVENT_FLOW_BEGIN0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_FLOW_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_FLOW_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                arg2_name, arg2_val)                     \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_BEGIN0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_BEGIN1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_BEGIN2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                     arg2_name, arg2_val)                     \
+  RTC_NOOP()
 
 #define TRACE_EVENT_FLOW_STEP0(category, name, id, step) RTC_NOOP()
-#define TRACE_EVENT_FLOW_STEP1(category, name, id, step, \
-        arg1_name, arg1_val) RTC_NOOP()
+#define TRACE_EVENT_FLOW_STEP1(category, name, id, step, arg1_name, arg1_val) \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_STEP0(category, name, id, step) RTC_NOOP()
-#define TRACE_EVENT_COPY_FLOW_STEP1(category, name, id, step, \
-        arg1_name, arg1_val) RTC_NOOP()
+#define TRACE_EVENT_COPY_FLOW_STEP1(category, name, id, step, arg1_name, \
+                                    arg1_val)                            \
+  RTC_NOOP()
 
 #define TRACE_EVENT_FLOW_END0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_FLOW_END1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_FLOW_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                              arg2_name, arg2_val)                     \
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_END0(category, name, id) RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_END1(category, name, id, arg1_name, arg1_val) \
-    RTC_NOOP()
+  RTC_NOOP()
 #define TRACE_EVENT_COPY_FLOW_END2(category, name, id, arg1_name, arg1_val, \
-        arg2_name, arg2_val) RTC_NOOP()
+                                   arg2_name, arg2_val)                     \
+  RTC_NOOP()
 
 #define TRACE_EVENT_API_GET_CATEGORY_ENABLED ""
 
diff --git a/rtc_base/units/unit_base.h b/rtc_base/units/unit_base.h
index e8f8ec1..a6bdbf5 100644
--- a/rtc_base/units/unit_base.h
+++ b/rtc_base/units/unit_base.h
@@ -141,10 +141,9 @@
   template <typename T>
   constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
   ToValue() const {
-    return IsPlusInfinity()
-               ? std::numeric_limits<T>::infinity()
-               : IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
-                                   : value_;
+    return IsPlusInfinity()    ? std::numeric_limits<T>::infinity()
+           : IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
+                               : value_;
   }
   template <typename T>
   constexpr T ToValueOr(T fallback_value) const {
diff --git a/rtc_base/win/create_direct3d_device.cc b/rtc_base/win/create_direct3d_device.cc
index 02fe340..35bbec1 100644
--- a/rtc_base/win/create_direct3d_device.cc
+++ b/rtc_base/win/create_direct3d_device.cc
@@ -11,6 +11,7 @@
 #include "rtc_base/win/create_direct3d_device.h"
 
 #include <libloaderapi.h>
+
 #include <utility>
 
 namespace {
diff --git a/rtc_base/win32_window.cc b/rtc_base/win32_window.cc
index 775535a..275237f 100644
--- a/rtc_base/win32_window.cc
+++ b/rtc_base/win32_window.cc
@@ -25,10 +25,18 @@
 
 Win32Window::Win32Window() : wnd_(nullptr) {}
 
-Win32Window::~Win32Window() { RTC_DCHECK(nullptr == wnd_); }
+Win32Window::~Win32Window() {
+  RTC_DCHECK(nullptr == wnd_);
+}
 
-bool Win32Window::Create(HWND parent, const wchar_t* title, DWORD style,
-                         DWORD exstyle, int x, int y, int cx, int cy) {
+bool Win32Window::Create(HWND parent,
+                         const wchar_t* title,
+                         DWORD style,
+                         DWORD exstyle,
+                         int x,
+                         int y,
+                         int cx,
+                         int cy) {
   if (wnd_) {
     // Window already exists.
     return false;
@@ -83,7 +91,9 @@
   }
 }
 
-bool Win32Window::OnMessage(UINT uMsg, WPARAM wParam, LPARAM lParam,
+bool Win32Window::OnMessage(UINT uMsg,
+                            WPARAM wParam,
+                            LPARAM lParam,
                             LRESULT& result) {
   switch (uMsg) {
     case WM_CLOSE:
@@ -96,13 +106,17 @@
   return false;
 }
 
-bool Win32Window::OnClose() { return true; }
+bool Win32Window::OnClose() {
+  return true;
+}
 
 void Win32Window::OnNcDestroy() {
   // Do nothing. }
 }
 
-LRESULT Win32Window::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam,
+LRESULT Win32Window::WndProc(HWND hwnd,
+                             UINT uMsg,
+                             WPARAM wParam,
                              LPARAM lParam) {
   Win32Window* that =
       reinterpret_cast<Win32Window*>(::GetWindowLongPtr(hwnd, GWLP_USERDATA));