diff --git a/rtc_tools/rtc_event_log_visualizer/plot_protobuf.cc b/rtc_tools/rtc_event_log_visualizer/plot_protobuf.cc
index 0f43191..0b7a6f2 100644
--- a/rtc_tools/rtc_event_log_visualizer/plot_protobuf.cc
+++ b/rtc_tools/rtc_event_log_visualizer/plot_protobuf.cc
@@ -24,8 +24,6 @@
 
 void ProtobufPlot::Draw() {}
 
-
-
 ProtobufPlotCollection::ProtobufPlotCollection() {}
 
 ProtobufPlotCollection::~ProtobufPlotCollection() {}
diff --git a/system_wrappers/include/metrics.h b/system_wrappers/include/metrics.h
index ca9ed6d..6e2da1b 100644
--- a/system_wrappers/include/metrics.h
+++ b/system_wrappers/include/metrics.h
@@ -32,8 +32,8 @@
 namespace metrics_impl {
 template <typename... Ts>
 void NoOp(const Ts&...) {}
-}
-}
+}  // namespace metrics_impl
+}  // namespace webrtc
 
 #if RTC_METRICS_ENABLED
 #define EXPECT_METRIC_EQ(val1, val2) EXPECT_EQ(val1, val2)
@@ -46,12 +46,16 @@
 #define EXPECT_METRIC_THAT(value, matcher) EXPECT_THAT(value, matcher)
 #else
 #define EXPECT_METRIC_EQ(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
-#define EXPECT_METRIC_EQ_WAIT(val1, val2, timeout) webrtc::metrics_impl::NoOp(val1, val2, timeout)
+#define EXPECT_METRIC_EQ_WAIT(val1, val2, timeout) \
+  webrtc::metrics_impl::NoOp(val1, val2, timeout)
 #define EXPECT_METRIC_GT(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
 #define EXPECT_METRIC_LE(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
-#define EXPECT_METRIC_TRUE(condition) webrtc::metrics_impl::NoOp(condition || true)
-#define EXPECT_METRIC_FALSE(condition) webrtc::metrics_impl::NoOp(condition && false)
-#define EXPECT_METRIC_THAT(value, matcher) webrtc::metrics_impl::NoOp(value, testing::_)
+#define EXPECT_METRIC_TRUE(condition) \
+  webrtc::metrics_impl::NoOp(condition || true)
+#define EXPECT_METRIC_FALSE(condition) \
+  webrtc::metrics_impl::NoOp(condition && false)
+#define EXPECT_METRIC_THAT(value, matcher) \
+  webrtc::metrics_impl::NoOp(value, testing::_)
 #endif
 
 #if RTC_METRICS_ENABLED
@@ -278,17 +282,23 @@
 // This section defines no-op alternatives to the metrics macros when
 // RTC_METRICS_ENABLED is defined.
 
-#define RTC_HISTOGRAM_COUNTS_100(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_100(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_200(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_200(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_500(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_500(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_1000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_1000(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_10000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_10000(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_100000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_100000(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
 #define RTC_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count) \
   webrtc::metrics_impl::NoOp(name, sample, min, max, bucket_count)
@@ -296,31 +306,41 @@
 #define RTC_HISTOGRAM_COUNTS_LINEAR(name, sample, min, max, bucket_count) \
   webrtc::metrics_impl::NoOp(name, sample, min, max, bucket_count)
 
-#define RTC_HISTOGRAM_COUNTS_SPARSE_100(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_SPARSE_100(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_SPARSE_200(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_SPARSE_200(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_SPARSE_500(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_SPARSE_500(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_SPARSE_1000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_SPARSE_1000(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_SPARSE_10000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_SPARSE_10000(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_COUNTS_SPARSE_100000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_COUNTS_SPARSE_100000(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
 #define RTC_HISTOGRAM_COUNTS_SPARSE(name, sample, min, max, bucket_count) \
   webrtc::metrics_impl::NoOp(name, sample, min, max, bucket_count)
 
-#define RTC_HISTOGRAM_PERCENTAGE_SPARSE(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_PERCENTAGE_SPARSE(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_BOOLEAN_SPARSE(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_BOOLEAN_SPARSE(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
 #define RTC_HISTOGRAM_ENUMERATION_SPARSE(name, sample, boundary) \
   webrtc::metrics_impl::NoOp(name, sample, boundary)
 
-#define RTC_HISTOGRAM_PERCENTAGE(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_PERCENTAGE(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
-#define RTC_HISTOGRAM_BOOLEAN(name, sample) webrtc::metrics_impl::NoOp(name, sample)
+#define RTC_HISTOGRAM_BOOLEAN(name, sample) \
+  webrtc::metrics_impl::NoOp(name, sample)
 
 #define RTC_HISTOGRAM_ENUMERATION(name, sample, boundary) \
   webrtc::metrics_impl::NoOp(name, sample, boundary)
@@ -332,11 +352,14 @@
 #define RTC_HISTOGRAM_COMMON_BLOCK_SLOW(name, sample, factory_get_invocation) \
   webrtc::metrics_impl::NoOp(name, sample, factory_get_invocation)
 
-#define RTC_HISTOGRAMS_COUNTS_100(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
+#define RTC_HISTOGRAMS_COUNTS_100(index, name, sample) \
+  webrtc::metrics_impl::NoOp(index, name, sample)
 
-#define RTC_HISTOGRAMS_COUNTS_200(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
+#define RTC_HISTOGRAMS_COUNTS_200(index, name, sample) \
+  webrtc::metrics_impl::NoOp(index, name, sample)
 
-#define RTC_HISTOGRAMS_COUNTS_500(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
+#define RTC_HISTOGRAMS_COUNTS_500(index, name, sample) \
+  webrtc::metrics_impl::NoOp(index, name, sample)
 
 #define RTC_HISTOGRAMS_COUNTS_1000(index, name, sample) \
   webrtc::metrics_impl::NoOp(index, name, sample)
@@ -350,7 +373,8 @@
 #define RTC_HISTOGRAMS_ENUMERATION(index, name, sample, boundary) \
   webrtc::metrics_impl::NoOp(index, name, sample, boundary)
 
-#define RTC_HISTOGRAMS_PERCENTAGE(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
+#define RTC_HISTOGRAMS_PERCENTAGE(index, name, sample) \
+  webrtc::metrics_impl::NoOp(index, name, sample)
 
 #define RTC_HISTOGRAMS_COMMON(index, name, sample, macro_invocation) \
   webrtc::metrics_impl::NoOp(index, name, sample, macro_invocation)
diff --git a/test/call_test.h b/test/call_test.h
index d01bac4..41db9ce 100644
--- a/test/call_test.h
+++ b/test/call_test.h
@@ -233,7 +233,6 @@
   rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
   test::FakeVideoRenderer fake_renderer_;
 
-
  private:
   absl::optional<RtpExtension> GetRtpExtensionByUri(
       const std::string& uri) const;
diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc
index 832df8a..79fda96 100644
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@@ -261,7 +261,7 @@
           uint32_t bitrate = current_rate_settings_.bitrate.GetBitrate(
               spatial_idx, temporal_idx);
           bitrate = static_cast<uint32_t>(
-              (bitrate * int64_t{max_target_bitrate_kbps_}) /
+              (bitrate* int64_t{max_target_bitrate_kbps_}) /
               allocated_bitrate_kbps);
           current_rate_settings_.bitrate.SetBitrate(spatial_idx, temporal_idx,
                                                     bitrate);
diff --git a/test/fuzzers/agc_fuzzer.cc b/test/fuzzers/agc_fuzzer.cc
index 5971039..0586708 100644
--- a/test/fuzzers/agc_fuzzer.cc
+++ b/test/fuzzers/agc_fuzzer.cc
@@ -92,8 +92,8 @@
   FuzzGainControllerConfig(fuzz_data, gci);
 
   // The audio buffer is used for both capture and render.
-  AudioBuffer audio(sample_rate_hz, num_channels, sample_rate_hz,
-                    num_channels, sample_rate_hz, num_channels);
+  AudioBuffer audio(sample_rate_hz, num_channels, sample_rate_hz, num_channels,
+                    sample_rate_hz, num_channels);
 
   std::vector<int16_t> packed_render_audio(samples_per_frame);
 
diff --git a/test/fuzzers/rtp_depacketizer_av1_assemble_frame_fuzzer.cc b/test/fuzzers/rtp_depacketizer_av1_assemble_frame_fuzzer.cc
index 168e7b6..7e9e702 100644
--- a/test/fuzzers/rtp_depacketizer_av1_assemble_frame_fuzzer.cc
+++ b/test/fuzzers/rtp_depacketizer_av1_assemble_frame_fuzzer.cc
@@ -7,14 +7,13 @@
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
-#include "modules/rtp_rtcp/source/video_rtp_depacketizer_av1.h"
-
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "api/array_view.h"
+#include "modules/rtp_rtcp/source/video_rtp_depacketizer_av1.h"
 #include "test/fuzzers/fuzz_data_helper.h"
 
 namespace webrtc {
diff --git a/test/network/cross_traffic.cc b/test/network/cross_traffic.cc
index 0a817a2..dd34bd0 100644
--- a/test/network/cross_traffic.cc
+++ b/test/network/cross_traffic.cc
@@ -142,33 +142,32 @@
 
 void TcpMessageRouteImpl::SendMessage(size_t size,
                                       std::function<void()> on_received) {
-  task_queue_->PostTask(
-      [this, size, handler = std::move(on_received)] {
-        // If we are currently sending a message we won't reset the connection,
-        // we'll act as if the messages are sent in the same TCP stream. This is
-        // intended to simulate recreation of a TCP session for each message
-        // in the typical case while avoiding the complexity overhead of
-        // maintaining multiple virtual TCP sessions in parallel.
-        if (pending_.empty() && in_flight_.empty()) {
-          cwnd_ = 10;
-          ssthresh_ = INFINITY;
-        }
-        int64_t data_left = static_cast<int64_t>(size);
-        int64_t kMaxPacketSize = 1200;
-        int64_t kMinPacketSize = 4;
-        Message message{std::move(handler)};
-        while (data_left > 0) {
-          int64_t packet_size = std::min(data_left, kMaxPacketSize);
-          int fragment_id = next_fragment_id_++;
-          pending_.push_back(MessageFragment{
-              fragment_id,
-              static_cast<size_t>(std::max(kMinPacketSize, packet_size))});
-          message.pending_fragment_ids.insert(fragment_id);
-          data_left -= packet_size;
-        }
-        messages_.emplace_back(message);
-        SendPackets(clock_->CurrentTime());
-      });
+  task_queue_->PostTask([this, size, handler = std::move(on_received)] {
+    // If we are currently sending a message we won't reset the connection,
+    // we'll act as if the messages are sent in the same TCP stream. This is
+    // intended to simulate recreation of a TCP session for each message
+    // in the typical case while avoiding the complexity overhead of
+    // maintaining multiple virtual TCP sessions in parallel.
+    if (pending_.empty() && in_flight_.empty()) {
+      cwnd_ = 10;
+      ssthresh_ = INFINITY;
+    }
+    int64_t data_left = static_cast<int64_t>(size);
+    int64_t kMaxPacketSize = 1200;
+    int64_t kMinPacketSize = 4;
+    Message message{std::move(handler)};
+    while (data_left > 0) {
+      int64_t packet_size = std::min(data_left, kMaxPacketSize);
+      int fragment_id = next_fragment_id_++;
+      pending_.push_back(MessageFragment{
+          fragment_id,
+          static_cast<size_t>(std::max(kMinPacketSize, packet_size))});
+      message.pending_fragment_ids.insert(fragment_id);
+      data_left -= packet_size;
+    }
+    messages_.emplace_back(message);
+    SendPackets(clock_->CurrentTime());
+  });
 }
 
 void TcpMessageRouteImpl::OnRequest(TcpPacket packet_info) {
diff --git a/test/network/fake_network_socket_server.cc b/test/network/fake_network_socket_server.cc
index c94c4e3..63828e5 100644
--- a/test/network/fake_network_socket_server.cc
+++ b/test/network/fake_network_socket_server.cc
@@ -113,7 +113,6 @@
   socket_server_->WakeUp();
 }
 
-
 rtc::SocketAddress FakeNetworkSocket::GetLocalAddress() const {
   RTC_DCHECK_RUN_ON(thread_);
   return local_addr_;
@@ -317,6 +316,5 @@
   wakeup_.Set();
 }
 
-
 }  // namespace test
 }  // namespace webrtc
diff --git a/test/network/fake_network_socket_server.h b/test/network/fake_network_socket_server.h
index 25c85d0..68624a7 100644
--- a/test/network/fake_network_socket_server.h
+++ b/test/network/fake_network_socket_server.h
@@ -32,7 +32,6 @@
   explicit FakeNetworkSocketServer(EndpointsContainer* endpoints_controller);
   ~FakeNetworkSocketServer() override;
 
-
   // rtc::SocketFactory methods:
   rtc::Socket* CreateSocket(int family, int type) override;
 
diff --git a/test/network/traffic_route.cc b/test/network/traffic_route.cc
index 81bb8ca..94db5ae 100644
--- a/test/network/traffic_route.cc
+++ b/test/network/traffic_route.cc
@@ -32,9 +32,7 @@
   explicit ActionReceiver(std::function<void()> action) : action_(action) {}
   ~ActionReceiver() override = default;
 
-  void OnPacketReceived(EmulatedIpPacket packet) override {
-    action_();
-  }
+  void OnPacketReceived(EmulatedIpPacket packet) override { action_(); }
 
  private:
   std::function<void()> action_;
diff --git a/test/peer_scenario/peer_scenario_client.cc b/test/peer_scenario/peer_scenario_client.cc
index 3947dbd..3419b9e 100644
--- a/test/peer_scenario/peer_scenario_client.cc
+++ b/test/peer_scenario/peer_scenario_client.cc
@@ -106,7 +106,7 @@
       handler(candidates);
   }
   void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
-                  const std::vector<rtc::scoped_refptr<MediaStreamInterface> >&
+                  const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
                       streams) override {
     for (const auto& handler : handlers_->on_add_track)
       handler(receiver, streams);
diff --git a/test/peer_scenario/tests/remote_estimate_test.cc b/test/peer_scenario/tests/remote_estimate_test.cc
index 2dfbfdd..fa343a7 100644
--- a/test/peer_scenario/tests/remote_estimate_test.cc
+++ b/test/peer_scenario/tests/remote_estimate_test.cc
@@ -61,7 +61,8 @@
 }
 
 TEST(RemoteEstimateEndToEnd, AudioUsesAbsSendTimeExtension) {
-  // Defined before PeerScenario so it gets destructed after, to avoid use after free.
+  // Defined before PeerScenario so it gets destructed after, to avoid use after
+  // free.
   std::atomic<bool> received_abs_send_time(false);
   PeerScenario s(*test_info_);
 
diff --git a/test/scenario/performance_stats.h b/test/scenario/performance_stats.h
index 6974ab6..eca1ee7 100644
--- a/test/scenario/performance_stats.h
+++ b/test/scenario/performance_stats.h
@@ -37,7 +37,6 @@
   int repeated = 0;
 };
 
-
 struct VideoFramesStats {
   int count = 0;
   SampleStats<double> pixels;
diff --git a/test/scenario/video_stream_unittest.cc b/test/scenario/video_stream_unittest.cc
index e53af4e..3c4ced0 100644
--- a/test/scenario/video_stream_unittest.cc
+++ b/test/scenario/video_stream_unittest.cc
@@ -106,7 +106,6 @@
       c->encoder.simulcast_streams = {webrtc::ScalabilityMode::kL1T1,
                                       webrtc::ScalabilityMode::kL1T1,
                                       webrtc::ScalabilityMode::kL1T1};
-
     });
     s.RunFor(kRunTime);
   }
diff --git a/test/testsupport/file_utils.cc b/test/testsupport/file_utils.cc
index ff0d5a8..47fed9a 100644
--- a/test/testsupport/file_utils.cc
+++ b/test/testsupport/file_utils.cc
@@ -10,7 +10,6 @@
 
 #include "test/testsupport/file_utils.h"
 
-
 #if defined(WEBRTC_POSIX)
 #include <unistd.h>
 #endif
diff --git a/test/video_encoder_proxy_factory.h b/test/video_encoder_proxy_factory.h
index cc485e9..99796c0 100644
--- a/test/video_encoder_proxy_factory.h
+++ b/test/video_encoder_proxy_factory.h
@@ -37,8 +37,7 @@
       : encoder_(encoder),
         encoder_selector_(encoder_selector),
         num_simultaneous_encoder_instances_(0),
-        max_num_simultaneous_encoder_instances_(0) {
-  }
+        max_num_simultaneous_encoder_instances_(0) {}
 
   // Unused by tests.
   std::vector<SdpVideoFormat> GetSupportedFormats() const override {
diff --git a/video/end_to_end_tests/call_operation_tests.cc b/video/end_to_end_tests/call_operation_tests.cc
index 7a026c3..4a8490b 100644
--- a/video/end_to_end_tests/call_operation_tests.cc
+++ b/video/end_to_end_tests/call_operation_tests.cc
@@ -98,38 +98,37 @@
 
   test::FrameForwarder frame_forwarder;
 
-  SendTask(
-      task_queue(), [this, &renderer, &frame_forwarder]() {
-        CreateCalls();
-        CreateSendTransport(BuiltInNetworkBehaviorConfig(),
-                            /*observer=*/nullptr);
+  SendTask(task_queue(), [this, &renderer, &frame_forwarder]() {
+    CreateCalls();
+    CreateSendTransport(BuiltInNetworkBehaviorConfig(),
+                        /*observer=*/nullptr);
 
-        CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
-                               /*observer=*/nullptr);
-        CreateSendConfig(1, 0, 0);
-        CreateMatchingReceiveConfigs();
+    CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
+                           /*observer=*/nullptr);
+    CreateSendConfig(1, 0, 0);
+    CreateMatchingReceiveConfigs();
 
-        video_receive_configs_[0].renderer = &renderer;
+    video_receive_configs_[0].renderer = &renderer;
 
-        CreateVideoStreams();
-        Start();
+    CreateVideoStreams();
+    Start();
 
-        // Create frames that are smaller than the send width/height, this is
-        // done to check that the callbacks are done after processing video.
-        std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
-            test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
-                                             absl::nullopt));
-        GetVideoSendStream()->SetSource(
-            &frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
+    // Create frames that are smaller than the send width/height, this is
+    // done to check that the callbacks are done after processing video.
+    std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
+        test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
+                                         absl::nullopt));
+    GetVideoSendStream()->SetSource(&frame_forwarder,
+                                    DegradationPreference::MAINTAIN_FRAMERATE);
 
-        test::FrameGeneratorInterface::VideoFrameData frame_data =
-            frame_generator->NextFrame();
-        VideoFrame frame = VideoFrame::Builder()
-                               .set_video_frame_buffer(frame_data.buffer)
-                               .set_update_rect(frame_data.update_rect)
-                               .build();
-        frame_forwarder.IncomingCapturedFrame(frame);
-      });
+    test::FrameGeneratorInterface::VideoFrameData frame_data =
+        frame_generator->NextFrame();
+    VideoFrame frame = VideoFrame::Builder()
+                           .set_video_frame_buffer(frame_data.buffer)
+                           .set_update_rect(frame_data.update_rect)
+                           .build();
+    frame_forwarder.IncomingCapturedFrame(frame);
+  });
 
   EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
@@ -159,35 +158,34 @@
   std::unique_ptr<test::DirectTransport> sender_transport;
   std::unique_ptr<test::DirectTransport> receiver_transport;
 
-  SendTask(
-      task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() {
-        CreateCalls();
-        CreateSendTransport(BuiltInNetworkBehaviorConfig(),
-                            /*observer=*/nullptr);
-        CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
-                               /*observer=*/nullptr);
+  SendTask(task_queue(), [this, &renderer, &frame_generator,
+                          &frame_forwarder]() {
+    CreateCalls();
+    CreateSendTransport(BuiltInNetworkBehaviorConfig(),
+                        /*observer=*/nullptr);
+    CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
+                           /*observer=*/nullptr);
 
-        CreateSendConfig(1, 0, 0);
-        CreateMatchingReceiveConfigs();
-        video_receive_configs_[0].renderer = &renderer;
+    CreateSendConfig(1, 0, 0);
+    CreateMatchingReceiveConfigs();
+    video_receive_configs_[0].renderer = &renderer;
 
-        CreateVideoStreams();
-        Start();
+    CreateVideoStreams();
+    Start();
 
-        frame_generator = test::CreateSquareFrameGenerator(
-            test::VideoTestConstants::kDefaultWidth,
-            test::VideoTestConstants::kDefaultHeight, absl::nullopt,
-            absl::nullopt);
-        GetVideoSendStream()->SetSource(
-            &frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
-        test::FrameGeneratorInterface::VideoFrameData frame_data =
-            frame_generator->NextFrame();
-        VideoFrame frame = VideoFrame::Builder()
-                               .set_video_frame_buffer(frame_data.buffer)
-                               .set_update_rect(frame_data.update_rect)
-                               .build();
-        frame_forwarder.IncomingCapturedFrame(frame);
-      });
+    frame_generator = test::CreateSquareFrameGenerator(
+        test::VideoTestConstants::kDefaultWidth,
+        test::VideoTestConstants::kDefaultHeight, absl::nullopt, absl::nullopt);
+    GetVideoSendStream()->SetSource(&frame_forwarder,
+                                    DegradationPreference::MAINTAIN_FRAMERATE);
+    test::FrameGeneratorInterface::VideoFrameData frame_data =
+        frame_generator->NextFrame();
+    VideoFrame frame = VideoFrame::Builder()
+                           .set_video_frame_buffer(frame_data.buffer)
+                           .set_update_rect(frame_data.update_rect)
+                           .build();
+    frame_forwarder.IncomingCapturedFrame(frame);
+  });
 
   EXPECT_TRUE(renderer.Wait())
       << "Timed out while waiting for the frame to render.";
diff --git a/video/end_to_end_tests/network_state_tests.cc b/video/end_to_end_tests/network_state_tests.cc
index a523465..e653860 100644
--- a/video/end_to_end_tests/network_state_tests.cc
+++ b/video/end_to_end_tests/network_state_tests.cc
@@ -94,23 +94,20 @@
     Transport* transport) {
   test::VideoEncoderProxyFactory encoder_factory(encoder);
 
-  SendTask(task_queue(),
-           [this, network_to_bring_up, &encoder_factory, transport]() {
-             CreateSenderCall(Call::Config(send_event_log_.get()));
-             sender_call_->SignalChannelNetworkState(network_to_bring_up,
-                                                     kNetworkUp);
+  SendTask(task_queue(), [this, network_to_bring_up, &encoder_factory,
+                          transport]() {
+    CreateSenderCall(Call::Config(send_event_log_.get()));
+    sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
-             CreateSendConfig(1, 0, 0, transport);
-             GetVideoSendConfig()->encoder_settings.encoder_factory =
-                 &encoder_factory;
-             CreateVideoStreams();
-             CreateFrameGeneratorCapturer(
-                 test::VideoTestConstants::kDefaultFramerate,
-                 test::VideoTestConstants::kDefaultWidth,
-                 test::VideoTestConstants::kDefaultHeight);
+    CreateSendConfig(1, 0, 0, transport);
+    GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
+    CreateVideoStreams();
+    CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+                                 test::VideoTestConstants::kDefaultWidth,
+                                 test::VideoTestConstants::kDefaultHeight);
 
-             Start();
-           });
+    Start();
+  });
 
   SleepMs(kSilenceTimeoutMs);
 
diff --git a/video/end_to_end_tests/ssrc_tests.cc b/video/end_to_end_tests/ssrc_tests.cc
index 296e7c3..547c2c7 100644
--- a/video/end_to_end_tests/ssrc_tests.cc
+++ b/video/end_to_end_tests/ssrc_tests.cc
@@ -95,43 +95,41 @@
   std::unique_ptr<test::DirectTransport> receive_transport;
   std::unique_ptr<PacketInputObserver> input_observer;
 
-  SendTask(
-      task_queue(),
-      [this, &send_transport, &receive_transport, &input_observer]() {
-        CreateCalls();
+  SendTask(task_queue(), [this, &send_transport, &receive_transport,
+                          &input_observer]() {
+    CreateCalls();
 
-        send_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
-            GetRegisteredExtensions());
-        receive_transport = std::make_unique<test::DirectTransport>(
-            task_queue(),
-            std::make_unique<FakeNetworkPipe>(
-                Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
-                                               BuiltInNetworkBehaviorConfig())),
-            receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
-            GetRegisteredExtensions());
-        input_observer =
-            std::make_unique<PacketInputObserver>(receiver_call_->Receiver());
-        send_transport->SetReceiver(input_observer.get());
-        receive_transport->SetReceiver(sender_call_->Receiver());
+    send_transport = std::make_unique<test::DirectTransport>(
+        task_queue(),
+        std::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
+        sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
+        GetRegisteredExtensions());
+    receive_transport = std::make_unique<test::DirectTransport>(
+        task_queue(),
+        std::make_unique<FakeNetworkPipe>(
+            Clock::GetRealTimeClock(),
+            std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
+        receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
+        GetRegisteredExtensions());
+    input_observer =
+        std::make_unique<PacketInputObserver>(receiver_call_->Receiver());
+    send_transport->SetReceiver(input_observer.get());
+    receive_transport->SetReceiver(sender_call_->Receiver());
 
-        CreateSendConfig(1, 0, 0, send_transport.get());
-        CreateMatchingReceiveConfigs(receive_transport.get());
+    CreateSendConfig(1, 0, 0, send_transport.get());
+    CreateMatchingReceiveConfigs(receive_transport.get());
 
-        CreateVideoStreams();
-        CreateFrameGeneratorCapturer(
-            test::VideoTestConstants::kDefaultFramerate,
-            test::VideoTestConstants::kDefaultWidth,
-            test::VideoTestConstants::kDefaultHeight);
-        Start();
+    CreateVideoStreams();
+    CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+                                 test::VideoTestConstants::kDefaultWidth,
+                                 test::VideoTestConstants::kDefaultHeight);
+    Start();
 
-        receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
-        video_receive_streams_.clear();
-      });
+    receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
+    video_receive_streams_.clear();
+  });
 
   // Wait() waits for a received packet.
   EXPECT_TRUE(input_observer->Wait());
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index 4a1c093..87a8eaa 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -516,42 +516,39 @@
 
   VideoEncoderConfig encoder_config_with_screenshare;
 
-  SendTask(
-      task_queue(), [this, &test, &send_config, &recv_config,
-                     &encoder_config_with_screenshare]() {
-        CreateSenderCall(send_config);
-        CreateReceiverCall(recv_config);
-        CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
-        CreateSendTransport(test.GetReceiveTransportConfig(), &test);
+  SendTask(task_queue(), [this, &test, &send_config, &recv_config,
+                          &encoder_config_with_screenshare]() {
+    CreateSenderCall(send_config);
+    CreateReceiverCall(recv_config);
+    CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
+    CreateSendTransport(test.GetReceiveTransportConfig(), &test);
 
-        receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
-        CreateSendConfig(1, 0, 0);
-        CreateMatchingReceiveConfigs();
+    receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
+    CreateSendConfig(1, 0, 0);
+    CreateMatchingReceiveConfigs();
 
-        // Modify send and receive configs.
-        GetVideoSendConfig()->rtp.nack.rtp_history_ms =
-            test::VideoTestConstants::kNackRtpHistoryMs;
-        video_receive_configs_[0].rtp.nack.rtp_history_ms =
-            test::VideoTestConstants::kNackRtpHistoryMs;
-        video_receive_configs_[0].renderer = &test;
-        // RTT needed for RemoteNtpTimeEstimator for the receive stream.
-        video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report =
-            true;
-        // Start with realtime video.
-        GetVideoEncoderConfig()->content_type =
-            VideoEncoderConfig::ContentType::kRealtimeVideo;
-        // Encoder config for the second part of the test uses screenshare.
-        encoder_config_with_screenshare = GetVideoEncoderConfig()->Copy();
-        encoder_config_with_screenshare.content_type =
-            VideoEncoderConfig::ContentType::kScreen;
+    // Modify send and receive configs.
+    GetVideoSendConfig()->rtp.nack.rtp_history_ms =
+        test::VideoTestConstants::kNackRtpHistoryMs;
+    video_receive_configs_[0].rtp.nack.rtp_history_ms =
+        test::VideoTestConstants::kNackRtpHistoryMs;
+    video_receive_configs_[0].renderer = &test;
+    // RTT needed for RemoteNtpTimeEstimator for the receive stream.
+    video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = true;
+    // Start with realtime video.
+    GetVideoEncoderConfig()->content_type =
+        VideoEncoderConfig::ContentType::kRealtimeVideo;
+    // Encoder config for the second part of the test uses screenshare.
+    encoder_config_with_screenshare = GetVideoEncoderConfig()->Copy();
+    encoder_config_with_screenshare.content_type =
+        VideoEncoderConfig::ContentType::kScreen;
 
-        CreateVideoStreams();
-        CreateFrameGeneratorCapturer(
-            test::VideoTestConstants::kDefaultFramerate,
-            test::VideoTestConstants::kDefaultWidth,
-            test::VideoTestConstants::kDefaultHeight);
-        Start();
-      });
+    CreateVideoStreams();
+    CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
+                                 test::VideoTestConstants::kDefaultWidth,
+                                 test::VideoTestConstants::kDefaultHeight);
+    Start();
+  });
 
   test.PerformTest();
 
diff --git a/video/picture_id_tests.cc b/video/picture_id_tests.cc
index 60d3f52..6caec13 100644
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@@ -255,19 +255,17 @@
   observer_.reset(
       new PictureIdObserver(PayloadStringToCodecType(payload_name)));
 
-  SendTask(
-      task_queue(), [this, encoder_factory, payload_name]() {
-        CreateCalls();
-        CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
-        CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0,
-                         send_transport_.get());
-        GetVideoSendConfig()->encoder_settings.encoder_factory =
-            encoder_factory;
-        GetVideoSendConfig()->rtp.payload_name = payload_name;
-        GetVideoEncoderConfig()->codec_type =
-            PayloadStringToCodecType(payload_name);
-        SetVideoEncoderConfig(/* number_of_streams */ 1);
-      });
+  SendTask(task_queue(), [this, encoder_factory, payload_name]() {
+    CreateCalls();
+    CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
+    CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0,
+                     send_transport_.get());
+    GetVideoSendConfig()->encoder_settings.encoder_factory = encoder_factory;
+    GetVideoSendConfig()->rtp.payload_name = payload_name;
+    GetVideoEncoderConfig()->codec_type =
+        PayloadStringToCodecType(payload_name);
+    SetVideoEncoderConfig(/* number_of_streams */ 1);
+  });
 }
 
 void PictureIdTest::SetVideoEncoderConfig(int num_streams) {
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index 12e88ac..ac11692 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -743,8 +743,7 @@
   PurgeOldStats();
   stats_.input_frame_rate =
       uma_container_->input_frame_rate_tracker_.ComputeRate();
-  stats_.frames =
-      uma_container_->input_frame_rate_tracker_.TotalSampleCount();
+  stats_.frames = uma_container_->input_frame_rate_tracker_.TotalSampleCount();
   stats_.content_type =
       content_type_ == VideoEncoderConfig::ContentType::kRealtimeVideo
           ? VideoContentType::UNSPECIFIED
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index cb24993..53621ed 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -1644,35 +1644,33 @@
       new_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20);
       BitrateConstraints bitrate_config;
 
-      SendTask(task_queue_,
-               [this, &new_route, &bitrate_config]() {
-                 RTC_DCHECK_RUN_ON(&task_queue_thread_);
-                 call_->GetTransportControllerSend()->OnNetworkRouteChanged(
-                     "transport", new_route);
-                 bitrate_config.start_bitrate_bps = kStartBitrateBps;
-                 call_->GetTransportControllerSend()->SetSdpBitrateParameters(
-                     bitrate_config);
-               });
+      SendTask(task_queue_, [this, &new_route, &bitrate_config]() {
+        RTC_DCHECK_RUN_ON(&task_queue_thread_);
+        call_->GetTransportControllerSend()->OnNetworkRouteChanged("transport",
+                                                                   new_route);
+        bitrate_config.start_bitrate_bps = kStartBitrateBps;
+        call_->GetTransportControllerSend()->SetSdpBitrateParameters(
+            bitrate_config);
+      });
 
       EXPECT_TRUE(Wait())
           << "Timed out while waiting for start bitrate to be exceeded.";
 
-      SendTask(
-          task_queue_, [this, &new_route, &bitrate_config]() {
-            RTC_DCHECK_RUN_ON(&task_queue_thread_);
-            bitrate_config.start_bitrate_bps = -1;
-            bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
-            call_->GetTransportControllerSend()->SetSdpBitrateParameters(
-                bitrate_config);
-            // TODO(holmer): We should set the last sent packet id here and
-            // verify that we correctly ignore any packet loss reported prior to
-            // that id.
-            new_route.local = rtc::RouteEndpoint::CreateWithNetworkId(
-                new_route.local.network_id() + 1);
-            call_->GetTransportControllerSend()->OnNetworkRouteChanged(
-                "transport", new_route);
-            EXPECT_GE(call_->GetStats().send_bandwidth_bps, kStartBitrateBps);
-          });
+      SendTask(task_queue_, [this, &new_route, &bitrate_config]() {
+        RTC_DCHECK_RUN_ON(&task_queue_thread_);
+        bitrate_config.start_bitrate_bps = -1;
+        bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
+        call_->GetTransportControllerSend()->SetSdpBitrateParameters(
+            bitrate_config);
+        // TODO(holmer): We should set the last sent packet id here and
+        // verify that we correctly ignore any packet loss reported prior to
+        // that id.
+        new_route.local = rtc::RouteEndpoint::CreateWithNetworkId(
+            new_route.local.network_id() + 1);
+        call_->GetTransportControllerSend()->OnNetworkRouteChanged("transport",
+                                                                   new_route);
+        EXPECT_GE(call_->GetStats().send_bandwidth_bps, kStartBitrateBps);
+      });
     }
 
    private:
@@ -3276,8 +3274,8 @@
   //      |    P_DIFF     |  R times
   //      +-+-+-+-+-+-+-+-+
   void VerifySsData(const RTPVideoHeaderVP9& vp9) const {
-    EXPECT_TRUE(vp9.ss_data_available);             // V
-    EXPECT_EQ(params_.num_spatial_layers,           // N_S + 1
+    EXPECT_TRUE(vp9.ss_data_available);    // V
+    EXPECT_EQ(params_.num_spatial_layers,  // N_S + 1
               vp9.num_spatial_layers);
     EXPECT_TRUE(vp9.spatial_layer_resolution_present);  // Y:1
 
@@ -4013,18 +4011,17 @@
   auto reset_fun = [this](const VideoSendStream::Config& send_stream_config,
                           const VideoEncoderConfig& encoder_config,
                           test::BaseTest* test) {
-    SendTask(task_queue(),
-             [this, &send_stream_config, &encoder_config, &test]() {
-               Stop();
-               DestroyVideoSendStreams();
-               SetVideoSendConfig(send_stream_config);
-               SetVideoEncoderConfig(encoder_config);
-               CreateVideoSendStreams();
-               SetVideoDegradation(DegradationPreference::MAINTAIN_RESOLUTION);
-               test->OnVideoStreamsCreated(GetVideoSendStream(),
-                                           video_receive_streams_);
-               Start();
-             });
+    SendTask(task_queue(), [this, &send_stream_config, &encoder_config,
+                            &test]() {
+      Stop();
+      DestroyVideoSendStreams();
+      SetVideoSendConfig(send_stream_config);
+      SetVideoEncoderConfig(encoder_config);
+      CreateVideoSendStreams();
+      SetVideoDegradation(DegradationPreference::MAINTAIN_RESOLUTION);
+      test->OnVideoStreamsCreated(GetVideoSendStream(), video_receive_streams_);
+      Start();
+    });
   };
   ContentSwitchTest<decltype(reset_fun)> test(&reset_fun, task_queue());
   RunBaseTest(&test);
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index e556ff9..44fdbaa 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -785,31 +785,30 @@
 
   rtc::Event shutdown_event;
   absl::Cleanup shutdown = [&shutdown_event] { shutdown_event.Set(); };
-  encoder_queue_.PostTask(
-      [this, shutdown = std::move(shutdown)] {
-        RTC_DCHECK_RUN_ON(&encoder_queue_);
-        if (resource_adaptation_processor_) {
-          stream_resource_manager_.StopManagedResources();
-          for (auto* constraint : adaptation_constraints_) {
-            video_stream_adapter_->RemoveAdaptationConstraint(constraint);
-          }
-          for (auto& resource : additional_resources_) {
-            stream_resource_manager_.RemoveResource(resource);
-          }
-          additional_resources_.clear();
-          video_stream_adapter_->RemoveRestrictionsListener(this);
-          video_stream_adapter_->RemoveRestrictionsListener(
-              &stream_resource_manager_);
-          resource_adaptation_processor_->RemoveResourceLimitationsListener(
-              &stream_resource_manager_);
-          stream_resource_manager_.SetAdaptationProcessor(nullptr, nullptr);
-          resource_adaptation_processor_.reset();
-        }
-        rate_allocator_ = nullptr;
-        ReleaseEncoder();
-        encoder_ = nullptr;
-        frame_cadence_adapter_ = nullptr;
-      });
+  encoder_queue_.PostTask([this, shutdown = std::move(shutdown)] {
+    RTC_DCHECK_RUN_ON(&encoder_queue_);
+    if (resource_adaptation_processor_) {
+      stream_resource_manager_.StopManagedResources();
+      for (auto* constraint : adaptation_constraints_) {
+        video_stream_adapter_->RemoveAdaptationConstraint(constraint);
+      }
+      for (auto& resource : additional_resources_) {
+        stream_resource_manager_.RemoveResource(resource);
+      }
+      additional_resources_.clear();
+      video_stream_adapter_->RemoveRestrictionsListener(this);
+      video_stream_adapter_->RemoveRestrictionsListener(
+          &stream_resource_manager_);
+      resource_adaptation_processor_->RemoveResourceLimitationsListener(
+          &stream_resource_manager_);
+      stream_resource_manager_.SetAdaptationProcessor(nullptr, nullptr);
+      resource_adaptation_processor_.reset();
+    }
+    rate_allocator_ = nullptr;
+    ReleaseEncoder();
+    encoder_ = nullptr;
+    frame_cadence_adapter_ = nullptr;
+  });
   shutdown_event.Wait(rtc::Event::kForever);
 }
 
@@ -915,48 +914,48 @@
                                           size_t max_data_payload_length,
                                           SetParametersCallback callback) {
   RTC_DCHECK_RUN_ON(worker_queue_);
-  encoder_queue_.PostTask(
-      [this, config = std::move(config), max_data_payload_length,
-       callback = std::move(callback)]() mutable {
-        RTC_DCHECK_RUN_ON(&encoder_queue_);
-        RTC_DCHECK(sink_);
-        RTC_LOG(LS_INFO) << "ConfigureEncoder requested.";
+  encoder_queue_.PostTask([this, config = std::move(config),
+                           max_data_payload_length,
+                           callback = std::move(callback)]() mutable {
+    RTC_DCHECK_RUN_ON(&encoder_queue_);
+    RTC_DCHECK(sink_);
+    RTC_LOG(LS_INFO) << "ConfigureEncoder requested.";
 
-        // Set up the frame cadence adapter according to if we're going to do
-        // screencast. The final number of spatial layers is based on info
-        // in `send_codec_`, which is computed based on incoming frame
-        // dimensions which can only be determined later.
-        //
-        // Note: zero-hertz mode isn't enabled by this alone. Constraints also
-        // have to be set up with min_fps = 0 and max_fps > 0.
-        if (config.content_type == VideoEncoderConfig::ContentType::kScreen) {
-          frame_cadence_adapter_->SetZeroHertzModeEnabled(
-              FrameCadenceAdapterInterface::ZeroHertzModeParams{});
-        } else {
-          frame_cadence_adapter_->SetZeroHertzModeEnabled(absl::nullopt);
-        }
+    // Set up the frame cadence adapter according to if we're going to do
+    // screencast. The final number of spatial layers is based on info
+    // in `send_codec_`, which is computed based on incoming frame
+    // dimensions which can only be determined later.
+    //
+    // Note: zero-hertz mode isn't enabled by this alone. Constraints also
+    // have to be set up with min_fps = 0 and max_fps > 0.
+    if (config.content_type == VideoEncoderConfig::ContentType::kScreen) {
+      frame_cadence_adapter_->SetZeroHertzModeEnabled(
+          FrameCadenceAdapterInterface::ZeroHertzModeParams{});
+    } else {
+      frame_cadence_adapter_->SetZeroHertzModeEnabled(absl::nullopt);
+    }
 
-        pending_encoder_creation_ =
-            (!encoder_ || encoder_config_.video_format != config.video_format ||
-             max_data_payload_length_ != max_data_payload_length);
-        encoder_config_ = std::move(config);
-        max_data_payload_length_ = max_data_payload_length;
-        pending_encoder_reconfiguration_ = true;
+    pending_encoder_creation_ =
+        (!encoder_ || encoder_config_.video_format != config.video_format ||
+         max_data_payload_length_ != max_data_payload_length);
+    encoder_config_ = std::move(config);
+    max_data_payload_length_ = max_data_payload_length;
+    pending_encoder_reconfiguration_ = true;
 
-        // Reconfigure the encoder now if the frame resolution is known.
-        // Otherwise, the reconfiguration is deferred until the next frame to
-        // minimize the number of reconfigurations. The codec configuration
-        // depends on incoming video frame size.
-        if (last_frame_info_) {
-          if (callback) {
-            encoder_configuration_callbacks_.push_back(std::move(callback));
-          }
+    // Reconfigure the encoder now if the frame resolution is known.
+    // Otherwise, the reconfiguration is deferred until the next frame to
+    // minimize the number of reconfigurations. The codec configuration
+    // depends on incoming video frame size.
+    if (last_frame_info_) {
+      if (callback) {
+        encoder_configuration_callbacks_.push_back(std::move(callback));
+      }
 
-          ReconfigureEncoder();
-        } else {
-          webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
-        }
-      });
+      ReconfigureEncoder();
+    } else {
+      webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
+    }
+  });
 }
 
 // We should reduce the number of 'full' ReconfigureEncoder(). If only need