diff --git a/common_video/bitrate_adjuster_unittest.cc b/common_video/bitrate_adjuster_unittest.cc
index 1ff911c..8660533 100644
--- a/common_video/bitrate_adjuster_unittest.cc
+++ b/common_video/bitrate_adjuster_unittest.cc
@@ -34,7 +34,7 @@
     const size_t frame_size_bytes =
         (bitrate_bps * frame_interval_ms) / (8 * 1000);
     for (size_t i = 0; i < update_frame_interval; ++i) {
-      clock_.AdvanceTime(webrtc::TimeDelta::Millis(frame_interval_ms));
+      clock_.AdvanceTime(TimeDelta::Millis(frame_interval_ms));
       adjuster_.Update(frame_size_bytes);
     }
   }
diff --git a/common_video/libyuv/libyuv_unittest.cc b/common_video/libyuv/libyuv_unittest.cc
index fbaf67c..b0e9794 100644
--- a/common_video/libyuv/libyuv_unittest.cc
+++ b/common_video/libyuv/libyuv_unittest.cc
@@ -97,8 +97,7 @@
       frame_length_(CalcBufferSize(VideoType::kI420, 352, 288)) {}
 
 void TestLibYuv::SetUp() {
-  const std::string input_file_name =
-      webrtc::test::ResourcePath("foreman_cif", "yuv");
+  const std::string input_file_name = test::ResourcePath("foreman_cif", "yuv");
   source_file_ = fopen(input_file_name.c_str(), "rb");
   ASSERT_TRUE(source_file_ != NULL)
       << "Cannot read file: " << input_file_name << "\n";
@@ -106,12 +105,11 @@
   scoped_refptr<I420BufferInterface> buffer(
       test::ReadI420Buffer(width_, height_, source_file_));
 
-  orig_frame_ =
-      std::make_unique<VideoFrame>(VideoFrame::Builder()
-                                       .set_video_frame_buffer(buffer)
-                                       .set_rotation(webrtc::kVideoRotation_0)
-                                       .set_timestamp_us(0)
-                                       .build());
+  orig_frame_ = std::make_unique<VideoFrame>(VideoFrame::Builder()
+                                                 .set_video_frame_buffer(buffer)
+                                                 .set_rotation(kVideoRotation_0)
+                                                 .set_timestamp_us(0)
+                                                 .build());
 }
 
 void TestLibYuv::TearDown() {
@@ -125,7 +123,7 @@
   // Reading YUV frame - testing on the first frame of the foreman sequence
   int j = 0;
   std::string output_file_name =
-      webrtc::test::OutputPath() + "LibYuvTest_conversion.yuv";
+      test::OutputPath() + "LibYuvTest_conversion.yuv";
   FILE* output_file = fopen(output_file_name.c_str(), "wb");
   ASSERT_TRUE(output_file != NULL);
 
@@ -291,7 +289,7 @@
 TEST_F(TestLibYuv, ConvertAlignedFrame) {
   // Reading YUV frame - testing on the first frame of the foreman sequence
   std::string output_file_name =
-      webrtc::test::OutputPath() + "LibYuvTest_conversion.yuv";
+      test::OutputPath() + "LibYuvTest_conversion.yuv";
   FILE* output_file = fopen(output_file_name.c_str(), "wb");
   ASSERT_TRUE(output_file != NULL);
 
diff --git a/common_video/video_frame_unittest.cc b/common_video/video_frame_unittest.cc
index c2611aa..21ddf8d 100644
--- a/common_video/video_frame_unittest.cc
+++ b/common_video/video_frame_unittest.cc
@@ -146,7 +146,7 @@
 template <class T>
 void CheckRotate(int width,
                  int height,
-                 webrtc::VideoRotation rotation,
+                 VideoRotation rotation,
                  const T& rotated) {
   int rotated_width = width;
   int rotated_height = height;
@@ -204,7 +204,7 @@
   VideoFrame frame =
       VideoFrame::Builder()
           .set_video_frame_buffer(I420Buffer::Create(10, 10, 10, 14, 90))
-          .set_rotation(webrtc::kVideoRotation_0)
+          .set_rotation(kVideoRotation_0)
           .set_timestamp_ms(789)
           .build();
   const int valid_value = 10;
@@ -251,10 +251,8 @@
   VideoFrame frame2(frame1);
 
   EXPECT_EQ(frame1.video_frame_buffer(), frame2.video_frame_buffer());
-  const webrtc::I420BufferInterface* yuv1 =
-      frame1.video_frame_buffer()->GetI420();
-  const webrtc::I420BufferInterface* yuv2 =
-      frame2.video_frame_buffer()->GetI420();
+  const I420BufferInterface* yuv1 = frame1.video_frame_buffer()->GetI420();
+  const I420BufferInterface* yuv2 = frame2.video_frame_buffer()->GetI420();
   EXPECT_EQ(yuv1->DataY(), yuv2->DataY());
   EXPECT_EQ(yuv1->DataU(), yuv2->DataU());
   EXPECT_EQ(yuv1->DataV(), yuv2->DataV());
@@ -276,8 +274,8 @@
 }
 
 TEST(TestVideoFrame, TextureInitialValues) {
-  VideoFrame frame = test::FakeNativeBuffer::CreateFrame(
-      640, 480, 100, 10, webrtc::kVideoRotation_0);
+  VideoFrame frame =
+      test::FakeNativeBuffer::CreateFrame(640, 480, 100, 10, kVideoRotation_0);
   EXPECT_EQ(640, frame.width());
   EXPECT_EQ(480, frame.height());
   EXPECT_EQ(100u, frame.rtp_timestamp());
@@ -425,7 +423,7 @@
 TYPED_TEST_SUITE_P(TestPlanarYuvBufferRotate);
 
 TYPED_TEST_P(TestPlanarYuvBufferRotate, Rotates) {
-  for (const webrtc::VideoRotation& rotation : this->RotationParams) {
+  for (const VideoRotation& rotation : this->RotationParams) {
     scoped_refptr<TypeParam> buffer = CreateGradient<TypeParam>(640, 480);
     scoped_refptr<TypeParam> rotated_buffer =
         TypeParam::Rotate(*buffer, rotation);
diff --git a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
index d6fce46..38bf7cf 100644
--- a/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
+++ b/logging/rtc_event_log/encoder/rtc_event_log_encoder_new_format.cc
@@ -170,19 +170,19 @@
 }
 
 rtclog2::DtlsTransportStateEvent::DtlsTransportState ConvertToProtoFormat(
-    webrtc::DtlsTransportState state) {
+    DtlsTransportState state) {
   switch (state) {
-    case webrtc::DtlsTransportState::kNew:
+    case DtlsTransportState::kNew:
       return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_NEW;
-    case webrtc::DtlsTransportState::kConnecting:
+    case DtlsTransportState::kConnecting:
       return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_CONNECTING;
-    case webrtc::DtlsTransportState::kConnected:
+    case DtlsTransportState::kConnected:
       return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_CONNECTED;
-    case webrtc::DtlsTransportState::kClosed:
+    case DtlsTransportState::kClosed:
       return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_CLOSED;
-    case webrtc::DtlsTransportState::kFailed:
+    case DtlsTransportState::kFailed:
       return rtclog2::DtlsTransportStateEvent::DTLS_TRANSPORT_FAILED;
-    case webrtc::DtlsTransportState::kNumValues:
+    case DtlsTransportState::kNumValues:
       RTC_DCHECK_NOTREACHED();
   }
   RTC_DCHECK_NOTREACHED();
diff --git a/logging/rtc_event_log/rtc_event_log_parser.cc b/logging/rtc_event_log/rtc_event_log_parser.cc
index aff0181..61ab4f5 100644
--- a/logging/rtc_event_log/rtc_event_log_parser.cc
+++ b/logging/rtc_event_log/rtc_event_log_parser.cc
@@ -1123,8 +1123,7 @@
 // is not stored in the event log.
 // TODO(ivoc): Remove this once this mapping is stored in the event log for
 //             audio streams. Tracking bug: webrtc:6399
-webrtc::RtpHeaderExtensionMap
-ParsedRtcEventLog::GetDefaultHeaderExtensionMap() {
+RtpHeaderExtensionMap ParsedRtcEventLog::GetDefaultHeaderExtensionMap() {
   // Values from before the default RTP header extension IDs were removed.
   constexpr int kAudioLevelDefaultId = 1;
   constexpr int kTimestampOffsetDefaultId = 2;
@@ -1136,7 +1135,7 @@
   constexpr int kVideoTimingDefaultId = 8;
   constexpr int kDependencyDescriptorDefaultId = 9;
 
-  webrtc::RtpHeaderExtensionMap default_map(/*extmap_allow_mixed=*/true);
+  RtpHeaderExtensionMap default_map(/*extmap_allow_mixed=*/true);
   default_map.Register<AudioLevelExtension>(kAudioLevelDefaultId);
   default_map.Register<TransmissionOffset>(kTimestampOffsetDefaultId);
   default_map.Register<AbsoluteSendTime>(kAbsSendTimeDefaultId);
diff --git a/video/buffered_frame_decryptor.cc b/video/buffered_frame_decryptor.cc
index 29ec8ae..03fc2eb 100644
--- a/video/buffered_frame_decryptor.cc
+++ b/video/buffered_frame_decryptor.cc
@@ -73,7 +73,7 @@
   }
   // Retrieve the maximum possible size of the decrypted payload.
   const size_t max_plaintext_byte_size =
-      frame_decryptor_->GetMaxPlaintextByteSize(webrtc::MediaType::VIDEO,
+      frame_decryptor_->GetMaxPlaintextByteSize(MediaType::VIDEO,
                                                 frame->size());
   RTC_CHECK_LE(max_plaintext_byte_size, frame->size());
   // Place the decrypted frame inline into the existing frame.
@@ -88,9 +88,8 @@
 
   // Attempt to decrypt the video frame.
   const FrameDecryptorInterface::Result decrypt_result =
-      frame_decryptor_->Decrypt(webrtc::MediaType::VIDEO, /*csrcs=*/{},
-                                additional_data, *frame,
-                                inline_decrypted_bitstream);
+      frame_decryptor_->Decrypt(MediaType::VIDEO, /*csrcs=*/{}, additional_data,
+                                *frame, inline_decrypted_bitstream);
   // Optionally call the callback if there was a change in status
   if (decrypt_result.status != last_status_) {
     last_status_ = decrypt_result.status;
diff --git a/video/config/encoder_stream_factory.cc b/video/config/encoder_stream_factory.cc
index 601c750..8820c98 100644
--- a/video/config/encoder_stream_factory.cc
+++ b/video/config/encoder_stream_factory.cc
@@ -42,7 +42,6 @@
 namespace webrtc {
 namespace {
 
-using ::webrtc::FieldTrialsView;
 
 const int kMinLayerSize = 16;
 
@@ -73,10 +72,10 @@
 }
 
 bool IsTemporalLayersSupported(VideoCodecType codec_type) {
-  return codec_type == webrtc::VideoCodecType::kVideoCodecVP8 ||
-         codec_type == webrtc::VideoCodecType::kVideoCodecVP9 ||
-         codec_type == webrtc::VideoCodecType::kVideoCodecAV1 ||
-         codec_type == webrtc::VideoCodecType::kVideoCodecH265;
+  return codec_type == VideoCodecType::kVideoCodecVP8 ||
+         codec_type == VideoCodecType::kVideoCodecVP9 ||
+         codec_type == VideoCodecType::kVideoCodecAV1 ||
+         codec_type == VideoCodecType::kVideoCodecH265;
 }
 
 size_t FindRequiredActiveLayers(const VideoEncoderConfig& encoder_config) {
@@ -111,14 +110,14 @@
 
 int GetDefaultMaxQp(VideoCodecType codec_type) {
   switch (codec_type) {
-    case webrtc::kVideoCodecH264:
-    case webrtc::kVideoCodecH265:
+    case kVideoCodecH264:
+    case kVideoCodecH265:
       return kDefaultVideoMaxQpH26x;
-    case webrtc::kVideoCodecVP8:
-    case webrtc::kVideoCodecVP9:
-    case webrtc::kVideoCodecGeneric:
+    case kVideoCodecVP8:
+    case kVideoCodecVP9:
+    case kVideoCodecGeneric:
       return kDefaultVideoMaxQpVpx;
-    case webrtc::kVideoCodecAV1:
+    case kVideoCodecAV1:
       return kDefaultVideoMaxQpAv1;
   }
 }
@@ -131,7 +130,7 @@
                            size_t simulcast_layers) {
   int base2_exponent = static_cast<int>(simulcast_layers) - 1;
   const std::optional<int> experimental_base2_exponent =
-      webrtc::NormalizeSimulcastSizeExperiment::GetBase2Exponent(field_trials);
+      NormalizeSimulcastSizeExperiment::GetBase2Exponent(field_trials);
   if (experimental_base2_exponent &&
       (size > (1 << *experimental_base2_exponent))) {
     base2_exponent = *experimental_base2_exponent;
@@ -149,10 +148,10 @@
 
   // Allow an experiment to override the minimum bitrate for the lowest
   // spatial layer. The experiment's configuration has the lowest priority.
-  layers[0].min_bitrate_bps = experimental_min_bitrate
-                                  .value_or(webrtc::DataRate::BitsPerSec(
-                                      webrtc::kDefaultMinVideoBitrateBps))
-                                  .bps<int>();
+  layers[0].min_bitrate_bps =
+      experimental_min_bitrate
+          .value_or(DataRate::BitsPerSec(kDefaultMinVideoBitrateBps))
+          .bps<int>();
 
   const bool temporal_layers_supported =
       IsTemporalLayersSupported(encoder_config.codec_type);
@@ -220,14 +219,14 @@
 
   bool is_highest_layer_max_bitrate_configured =
       encoder_config.simulcast_layers[layers.size() - 1].max_bitrate_bps > 0;
-  bool is_screencast = encoder_config.content_type ==
-                       webrtc::VideoEncoderConfig::ContentType::kScreen;
+  bool is_screencast =
+      encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen;
   if (!is_screencast && !is_highest_layer_max_bitrate_configured &&
       encoder_config.max_bitrate_bps > 0) {
     // No application-configured maximum for the largest layer.
     // If there is bitrate leftover, give it to the largest layer.
-    webrtc::BoostMaxSimulcastLayer(
-        webrtc::DataRate::BitsPerSec(encoder_config.max_bitrate_bps), &layers);
+    BoostMaxSimulcastLayer(DataRate::BitsPerSec(encoder_config.max_bitrate_bps),
+                           &layers);
   }
 
   // Sort the layers by max_bitrate_bps, they might not always be from
@@ -259,7 +258,7 @@
 }  // namespace
 
 EncoderStreamFactory::EncoderStreamFactory(
-    const webrtc::VideoEncoder::EncoderInfo& encoder_info,
+    const VideoEncoder::EncoderInfo& encoder_info,
     std::optional<VideoSourceRestrictions> restrictions)
     : encoder_info_requested_resolution_alignment_(
           encoder_info.requested_resolution_alignment),
@@ -296,7 +295,7 @@
 
   std::vector<VideoStream> streams;
   if (is_simulcast ||
-      webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
+      SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
     streams = CreateSimulcastOrConferenceModeScreenshareStreams(
         trials, frame_width, frame_height, encoder_config,
         experimental_min_bitrate);
@@ -318,8 +317,8 @@
     int height,
     const VideoEncoderConfig& encoder_config,
     const std::optional<DataRate>& experimental_min_bitrate) const {
-  bool is_screencast = encoder_config.content_type ==
-                       webrtc::VideoEncoderConfig::ContentType::kScreen;
+  bool is_screencast =
+      encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen;
 
   // The max bitrate specified by the API.
   // - `encoder_config.simulcast_layers[0].max_bitrate_bps` comes from the first
@@ -346,8 +345,8 @@
 
   int min_bitrate_bps =
       experimental_min_bitrate
-          ? webrtc::saturated_cast<int>(experimental_min_bitrate->bps())
-          : webrtc::kDefaultMinVideoBitrateBps;
+          ? saturated_cast<int>(experimental_min_bitrate->bps())
+          : kDefaultMinVideoBitrateBps;
   if (encoder_config.simulcast_layers[0].min_bitrate_bps > 0) {
     // Use set min bitrate.
     min_bitrate_bps = encoder_config.simulcast_layers[0].min_bitrate_bps;
@@ -388,7 +387,7 @@
         kMinLayerSize);
   }
 
-  if (encoder_config.codec_type == webrtc::VideoCodecType::kVideoCodecVP9) {
+  if (encoder_config.codec_type == VideoCodecType::kVideoCodecVP9) {
     RTC_DCHECK(encoder_config.encoder_specific_settings);
     // Use VP9 SVC layering from codec settings which might be initialized
     // though field trial in ConfigureVideoEncoderSettings.
@@ -407,12 +406,12 @@
         (layer.num_temporal_layers > 1u || num_spatial_layers > 1)) {
       // In SVC mode, the VP9 max bitrate is determined by SvcConfig, instead of
       // GetMaxDefaultVideoBitrateKbps().
-      std::vector<webrtc::SpatialLayer> svc_layers =
-          webrtc::GetSvcConfig(width, height, max_framerate,
-                               /*first_active_layer=*/0, num_spatial_layers,
-                               *layer.num_temporal_layers, is_screencast);
+      std::vector<SpatialLayer> svc_layers =
+          GetSvcConfig(width, height, max_framerate,
+                       /*first_active_layer=*/0, num_spatial_layers,
+                       *layer.num_temporal_layers, is_screencast);
       int sum_max_bitrates_kbps = 0;
-      for (const webrtc::SpatialLayer& spatial_layer : svc_layers) {
+      for (const SpatialLayer& spatial_layer : svc_layers) {
         sum_max_bitrates_kbps += spatial_layer.maxBitrate;
       }
       RTC_DCHECK_GE(sum_max_bitrates_kbps, 0);
@@ -468,9 +467,9 @@
 
   // Use legacy simulcast screenshare if conference mode is explicitly enabled
   // or use the regular simulcast configuration path which is generic.
-  std::vector<VideoStream> layers = webrtc::GetSimulcastConfig(
+  std::vector<VideoStream> layers = GetSimulcastConfig(
       resolutions,
-      webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
+      SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
       IsTemporalLayersSupported(encoder_config.codec_type), trials,
       encoder_config.codec_type);
 
@@ -509,8 +508,8 @@
     VideoSinkWants wants;
     wants.is_active = true;
     wants.target_pixel_count = restrictions_->target_pixels_per_frame();
-    wants.max_pixel_count = webrtc::dchecked_cast<int>(
-        restrictions_->max_pixels_per_frame().value_or(
+    wants.max_pixel_count =
+        dchecked_cast<int>(restrictions_->max_pixels_per_frame().value_or(
             std::numeric_limits<int>::max()));
     wants.aggregates.emplace(VideoSinkWants::Aggregates());
     wants.resolution_alignment = encoder_info_requested_resolution_alignment_;
@@ -532,7 +531,7 @@
     int height,
     const VideoEncoderConfig& encoder_config) const {
   std::vector<Resolution> resolutions;
-  if (webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
+  if (SimulcastUtility::IsConferenceModeScreenshare(encoder_config)) {
     for (size_t i = 0; i < encoder_config.number_of_streams; ++i) {
       resolutions.push_back({.width = width, .height = height});
     }
@@ -540,7 +539,7 @@
     size_t min_num_layers = FindRequiredActiveLayers(encoder_config);
     size_t max_num_layers =
         !encoder_config.HasScaleResolutionDownTo()
-            ? webrtc::LimitSimulcastLayerCount(
+            ? LimitSimulcastLayerCount(
                   min_num_layers, encoder_config.number_of_streams, width,
                   height, trials, encoder_config.codec_type)
             : encoder_config.number_of_streams;
@@ -556,8 +555,8 @@
     if (encoder_config.HasScaleResolutionDownTo() &&
         restrictions_.has_value() &&
         restrictions_->max_pixels_per_frame().has_value()) {
-      int max_pixels = webrtc::dchecked_cast<int>(
-          restrictions_->max_pixels_per_frame().value());
+      int max_pixels =
+          dchecked_cast<int>(restrictions_->max_pixels_per_frame().value());
       int prev_pixel_count =
           encoder_config.simulcast_layers[0]
               .scale_resolution_down_to.value_or(Resolution())
@@ -592,8 +591,7 @@
     }
 
     const bool norm_size_configured =
-        webrtc::NormalizeSimulcastSizeExperiment::GetBase2Exponent(trials)
-            .has_value();
+        NormalizeSimulcastSizeExperiment::GetBase2Exponent(trials).has_value();
     const int normalized_width =
         (default_scale_factors_used || norm_size_configured) &&
                 (width >= kMinLayerSize)
diff --git a/video/config/encoder_stream_factory_unittest.cc b/video/config/encoder_stream_factory_unittest.cc
index a36efaa..5c93527 100644
--- a/video/config/encoder_stream_factory_unittest.cc
+++ b/video/config/encoder_stream_factory_unittest.cc
@@ -42,7 +42,6 @@
 using ::testing::SizeIs;
 using ::testing::TestWithParam;
 using ::testing::Values;
-using ::webrtc::EncoderStreamFactory;
 
 struct CreateVideoStreamParams {
   int width = 0;
@@ -482,7 +481,7 @@
                           .scalability_mode = ScalabilityMode::kL1T2})}}),
             Values(
 #ifdef RTC_ENABLE_H265
-                webrtc::kVideoCodecH265,
+                kVideoCodecH265,
 #endif
                 VideoCodecType::kVideoCodecAV1,
                 VideoCodecType::kVideoCodecVP9)));
diff --git a/video/config/simulcast.cc b/video/config/simulcast.cc
index 66e9005..acc2e15 100644
--- a/video/config/simulcast.cc
+++ b/video/config/simulcast.cc
@@ -37,7 +37,6 @@
 
 namespace {
 
-using ::webrtc::FieldTrialsView;
 
 constexpr char kUseLegacySimulcastLayerLimitFieldTrial[] =
     "WebRTC-LegacySimulcastLayerLimit";
@@ -47,16 +46,16 @@
 // Limits for legacy conference screensharing mode. Currently used for the
 // lower of the two simulcast streams.
 constexpr DataRate kScreenshareDefaultTl0Bitrate =
-    webrtc::DataRate::KilobitsPerSec(200);
+    DataRate::KilobitsPerSec(200);
 constexpr DataRate kScreenshareDefaultTl1Bitrate =
-    webrtc::DataRate::KilobitsPerSec(1000);
+    DataRate::KilobitsPerSec(1000);
 
 // Min/max bitrate for the higher one of the two simulcast stream used for
 // screen content.
 constexpr DataRate kScreenshareHighStreamMinBitrate =
-    webrtc::DataRate::KilobitsPerSec(600);
+    DataRate::KilobitsPerSec(600);
 constexpr DataRate kScreenshareHighStreamMaxBitrate =
-    webrtc::DataRate::KilobitsPerSec(1250);
+    DataRate::KilobitsPerSec(1250);
 
 constexpr int kDefaultNumTemporalLayers = 3;
 constexpr int kScreenshareMaxSimulcastLayers = 2;
@@ -83,62 +82,47 @@
 // simulcast layers at what bitrates (maximum, target, and minimum).
 // Important!! Keep this table from high resolution to low resolution.
 constexpr const SimulcastFormat kSimulcastFormatsVP8[] = {
-    {1920, 1080, 3, webrtc::DataRate::KilobitsPerSec(5000),
-     webrtc::DataRate::KilobitsPerSec(4000),
-     webrtc::DataRate::KilobitsPerSec(800)},
-    {1280, 720, 3, webrtc::DataRate::KilobitsPerSec(2500),
-     webrtc::DataRate::KilobitsPerSec(2500),
-     webrtc::DataRate::KilobitsPerSec(600)},
-    {960, 540, 3, webrtc::DataRate::KilobitsPerSec(1200),
-     webrtc::DataRate::KilobitsPerSec(1200),
-     webrtc::DataRate::KilobitsPerSec(350)},
-    {640, 360, 2, webrtc::DataRate::KilobitsPerSec(700),
-     webrtc::DataRate::KilobitsPerSec(500),
-     webrtc::DataRate::KilobitsPerSec(150)},
-    {480, 270, 2, webrtc::DataRate::KilobitsPerSec(450),
-     webrtc::DataRate::KilobitsPerSec(350),
-     webrtc::DataRate::KilobitsPerSec(150)},
-    {320, 180, 1, webrtc::DataRate::KilobitsPerSec(200),
-     webrtc::DataRate::KilobitsPerSec(150),
-     webrtc::DataRate::KilobitsPerSec(30)},
+    {1920, 1080, 3, DataRate::KilobitsPerSec(5000),
+     DataRate::KilobitsPerSec(4000), DataRate::KilobitsPerSec(800)},
+    {1280, 720, 3, DataRate::KilobitsPerSec(2500),
+     DataRate::KilobitsPerSec(2500), DataRate::KilobitsPerSec(600)},
+    {960, 540, 3, DataRate::KilobitsPerSec(1200),
+     DataRate::KilobitsPerSec(1200), DataRate::KilobitsPerSec(350)},
+    {640, 360, 2, DataRate::KilobitsPerSec(700), DataRate::KilobitsPerSec(500),
+     DataRate::KilobitsPerSec(150)},
+    {480, 270, 2, DataRate::KilobitsPerSec(450), DataRate::KilobitsPerSec(350),
+     DataRate::KilobitsPerSec(150)},
+    {320, 180, 1, DataRate::KilobitsPerSec(200), DataRate::KilobitsPerSec(150),
+     DataRate::KilobitsPerSec(30)},
     // As the resolution goes down, interpolate the target and max bitrates down
     // towards zero. The min bitrate is still limited at 30 kbps and the target
     // and the max will be capped from below accordingly.
-    {0, 0, 1, webrtc::DataRate::KilobitsPerSec(0),
-     webrtc::DataRate::KilobitsPerSec(0),
-     webrtc::DataRate::KilobitsPerSec(30)}};
+    {0, 0, 1, DataRate::KilobitsPerSec(0), DataRate::KilobitsPerSec(0),
+     DataRate::KilobitsPerSec(30)}};
 
 // These tables describe from which resolution we can use how many
 // simulcast layers at what bitrates (maximum, target, and minimum).
 // Important!! Keep this table from high resolution to low resolution.
 constexpr const SimulcastFormat kSimulcastFormatsVP9[] = {
-    {1920, 1080, 3, webrtc::DataRate::KilobitsPerSec(3367),
-     webrtc::DataRate::KilobitsPerSec(3367),
-     webrtc::DataRate::KilobitsPerSec(769)},
-    {1280, 720, 3, webrtc::DataRate::KilobitsPerSec(1524),
-     webrtc::DataRate::KilobitsPerSec(1524),
-     webrtc::DataRate::KilobitsPerSec(481)},
-    {960, 540, 3, webrtc::DataRate::KilobitsPerSec(879),
-     webrtc::DataRate::KilobitsPerSec(879),
-     webrtc::DataRate::KilobitsPerSec(337)},
-    {640, 360, 2, webrtc::DataRate::KilobitsPerSec(420),
-     webrtc::DataRate::KilobitsPerSec(420),
-     webrtc::DataRate::KilobitsPerSec(193)},
-    {480, 270, 2, webrtc::DataRate::KilobitsPerSec(257),
-     webrtc::DataRate::KilobitsPerSec(257),
-     webrtc::DataRate::KilobitsPerSec(121)},
-    {320, 180, 1, webrtc::DataRate::KilobitsPerSec(142),
-     webrtc::DataRate::KilobitsPerSec(142),
-     webrtc::DataRate::KilobitsPerSec(30)},
-    {240, 135, 1, webrtc::DataRate::KilobitsPerSec(101),
-     webrtc::DataRate::KilobitsPerSec(101),
-     webrtc::DataRate::KilobitsPerSec(30)},
+    {1920, 1080, 3, DataRate::KilobitsPerSec(3367),
+     DataRate::KilobitsPerSec(3367), DataRate::KilobitsPerSec(769)},
+    {1280, 720, 3, DataRate::KilobitsPerSec(1524),
+     DataRate::KilobitsPerSec(1524), DataRate::KilobitsPerSec(481)},
+    {960, 540, 3, DataRate::KilobitsPerSec(879), DataRate::KilobitsPerSec(879),
+     DataRate::KilobitsPerSec(337)},
+    {640, 360, 2, DataRate::KilobitsPerSec(420), DataRate::KilobitsPerSec(420),
+     DataRate::KilobitsPerSec(193)},
+    {480, 270, 2, DataRate::KilobitsPerSec(257), DataRate::KilobitsPerSec(257),
+     DataRate::KilobitsPerSec(121)},
+    {320, 180, 1, DataRate::KilobitsPerSec(142), DataRate::KilobitsPerSec(142),
+     DataRate::KilobitsPerSec(30)},
+    {240, 135, 1, DataRate::KilobitsPerSec(101), DataRate::KilobitsPerSec(101),
+     DataRate::KilobitsPerSec(30)},
     // As the resolution goes down, interpolate the target and max bitrates down
     // towards zero. The min bitrate is still limited at 30 kbps and the target
     // and the max will be capped from below accordingly.
-    {0, 0, 1, webrtc::DataRate::KilobitsPerSec(0),
-     webrtc::DataRate::KilobitsPerSec(0),
-     webrtc::DataRate::KilobitsPerSec(30)}};
+    {0, 0, 1, DataRate::KilobitsPerSec(0), DataRate::KilobitsPerSec(0),
+     DataRate::KilobitsPerSec(30)}};
 
 constexpr DataRate Interpolate(const DataRate& a,
                                const DataRate& b,
@@ -154,16 +138,16 @@
 
 int GetDefaultSimulcastTemporalLayers(VideoCodecType codec) {
   switch (codec) {
-    case webrtc::kVideoCodecVP8:
-    case webrtc::kVideoCodecVP9:
-    case webrtc::kVideoCodecAV1:
-    case webrtc::kVideoCodecH264:
-    case webrtc::kVideoCodecGeneric:
+    case kVideoCodecVP8:
+    case kVideoCodecVP9:
+    case kVideoCodecAV1:
+    case kVideoCodecH264:
+    case kVideoCodecGeneric:
       return kDefaultNumTemporalLayers;
     // For codec type that has no software fallback, defaults to L1T1 for
     // initial simulcast setup, as this is the only scalability mode secure to
     // be supported.
-    case webrtc::kVideoCodecH265:
+    case kVideoCodecH265:
       return 1;
   }
   RTC_DCHECK_NOTREACHED() << "Unsupported codec.";
@@ -175,15 +159,15 @@
     VideoCodecType codec) {
   std::vector<SimulcastFormat> formats;
   switch (codec) {
-    case webrtc::kVideoCodecGeneric:
-    case webrtc::kVideoCodecVP8:
-    case webrtc::kVideoCodecH264:
+    case kVideoCodecGeneric:
+    case kVideoCodecVP8:
+    case kVideoCodecH264:
       formats.insert(formats.begin(), std::begin(kSimulcastFormatsVP8),
                      std::end(kSimulcastFormatsVP8));
       break;
-    case webrtc::kVideoCodecVP9:
-    case webrtc::kVideoCodecAV1:
-    case webrtc::kVideoCodecH265:
+    case kVideoCodecVP9:
+    case kVideoCodecAV1:
+    case kVideoCodecH265:
       formats.insert(formats.begin(), std::begin(kSimulcastFormatsVP9),
                      std::end(kSimulcastFormatsVP9));
       break;
@@ -323,7 +307,7 @@
   layers[0].width = width;
   layers[0].height = height;
   layers[0].max_framerate = 5;
-  layers[0].min_bitrate_bps = webrtc::kDefaultMinVideoBitrateBps;
+  layers[0].min_bitrate_bps = kDefaultMinVideoBitrateBps;
   layers[0].target_bitrate_bps = kScreenshareDefaultTl0Bitrate.bps();
   layers[0].max_bitrate_bps = kScreenshareDefaultTl1Bitrate.bps();
   layers[0].num_temporal_layers = temporal_layers_supported ? 2 : 1;
@@ -340,7 +324,7 @@
       // layers were enabled.
       max_bitrate_bps = static_cast<int>(
           kScreenshareHighStreamMaxBitrate.bps() *
-          webrtc::SimulcastRateAllocator::GetTemporalRateAllocation(
+          SimulcastRateAllocator::GetTemporalRateAllocation(
               kScreenshareTemporalLayers, 0, base_heavy_tl3_rate_alloc));
     } else {
       // Experimental temporal layer mode used, use increased max bitrate.
@@ -378,8 +362,8 @@
     // than configured `max_ratio`. pixels_down is the selected index in
     // kSimulcastFormats based on pixels.
     FieldTrialOptional<double> max_ratio("max_ratio");
-    webrtc::ParseFieldTrial({&max_ratio},
-                            trials.Lookup("WebRTC-SimulcastLayerLimitRoundUp"));
+    ParseFieldTrial({&max_ratio},
+                    trials.Lookup("WebRTC-SimulcastLayerLimitRoundUp"));
 
     size_t reduced_num_layers =
         std::max(min_num_layers,
@@ -413,14 +397,14 @@
 
 DataRate GetTotalMaxBitrate(const std::vector<VideoStream>& layers) {
   if (layers.empty())
-    return webrtc::DataRate::Zero();
+    return DataRate::Zero();
 
   int total_max_bitrate_bps = 0;
   for (size_t s = 0; s < layers.size() - 1; ++s) {
     total_max_bitrate_bps += layers[s].target_bitrate_bps;
   }
   total_max_bitrate_bps += layers.back().max_bitrate_bps;
-  return webrtc::DataRate::BitsPerSec(total_max_bitrate_bps);
+  return DataRate::BitsPerSec(total_max_bitrate_bps);
 }
 
 std::vector<VideoStream> GetSimulcastConfig(
diff --git a/video/config/simulcast_unittest.cc b/video/config/simulcast_unittest.cc
index 94b48fe..628e4ea 100644
--- a/video/config/simulcast_unittest.cc
+++ b/video/config/simulcast_unittest.cc
@@ -73,7 +73,7 @@
 std::vector<Resolution> CreateResolutions(int max_width,
                                           int max_height,
                                           int num_streams) {
-  std::vector<webrtc::Resolution> resolutions(num_streams);
+  std::vector<Resolution> resolutions(num_streams);
   for (int i = 0; i < num_streams; ++i) {
     resolutions[i].width = max_width >> (num_streams - i - 1);
     resolutions[i].height = max_height >> (num_streams - i - 1);
@@ -107,10 +107,10 @@
   streams[1].target_bitrate_bps = 200000;
   streams[2].max_bitrate_bps = 400000;
 
-  const webrtc::DataRate one_bps = webrtc::DataRate::BitsPerSec(1);
+  const DataRate one_bps = DataRate::BitsPerSec(1);
 
   // No bitrate above the total max to give to the highest stream.
-  const webrtc::DataRate max_total_bitrate = GetTotalMaxBitrate(streams);
+  const DataRate max_total_bitrate = GetTotalMaxBitrate(streams);
   BoostMaxSimulcastLayer(max_total_bitrate, &streams);
   EXPECT_EQ(400000, streams[2].max_bitrate_bps);
   EXPECT_EQ(max_total_bitrate, GetTotalMaxBitrate(streams));
@@ -129,7 +129,7 @@
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams =
       GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
-                         !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+                         !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(320u, streams[0].width);
@@ -157,7 +157,7 @@
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams =
       GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
-                         !kScreenshare, true, trials, webrtc::kVideoCodecH265);
+                         !kScreenshare, true, trials, kVideoCodecH265);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(320u, streams[0].width);
@@ -188,7 +188,7 @@
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams =
       GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
-                         !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+                         !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(kExpected[0].min_bitrate_bps, streams[0].min_bitrate_bps);
@@ -209,7 +209,7 @@
   const size_t kMaxLayers = 2;
   std::vector<VideoStream> streams =
       GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
-                         !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+                         !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(640u, streams[0].width);
@@ -224,7 +224,7 @@
       std::vector<Resolution>{{.width = 1400, .height = 800},
                               {.width = 1400, .height = 800},
                               {.width = 1400, .height = 800}},
-      kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+      kScreenshare, true, trials, kVideoCodecVP8);
 
   EXPECT_THAT(streams, SizeIs(2));
   for (size_t i = 0; i < streams.size(); ++i) {
@@ -244,7 +244,7 @@
   ExplicitKeyValueConfig trials("");
   std::vector<VideoStream> streams = GetSimulcastConfig(
       std::vector<Resolution>{{.width = 1400, .height = 800}}, kScreenshare,
-      true, trials, webrtc::kVideoCodecVP8);
+      true, trials, kVideoCodecVP8);
   EXPECT_THAT(streams, SizeIs(1));
 }
 
@@ -252,7 +252,7 @@
   ExplicitKeyValueConfig trials("");
   std::vector<VideoStream> streams =
       GetSimulcastConfig(std::vector<Resolution>{{.width = 900, .height = 800}},
-                         !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+                         !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(1));
   EXPECT_EQ(900u, streams[0].width);
@@ -273,7 +273,7 @@
 
   std::vector<VideoStream> streams =
       GetSimulcastConfig(CreateResolutions(kWidth, kHeight, kMaxLayers),
-                         !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+                         !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(kWidth, streams[2].width);
@@ -296,18 +296,18 @@
   const int kMaxLayers = 3;
 
   size_t num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 540,
-                                               trials, webrtc::kVideoCodecVP8);
+                                               trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 3u);
   // <960x540: 2 layers
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 539,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 270,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   // <480x270: 1 layer
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 269,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 1u);
 }
 
@@ -318,24 +318,24 @@
   const int kMaxLayers = 3;
 
   size_t num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 540,
-                                               trials, webrtc::kVideoCodecVP8);
+                                               trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 3u);
   // Lowest cropped height where max layers from higher resolution is used.
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 512,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 3u);
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 960, 508,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 270,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   // Lowest cropped height where max layers from higher resolution is used.
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 256,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 254,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 1u);
 }
 
@@ -347,14 +347,14 @@
   const int kMaxLayers = 3;
 
   size_t num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 270,
-                                               trials, webrtc::kVideoCodecVP8);
+                                               trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   // Lowest cropped height where max layers from higher resolution is used.
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 252,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 2u);
   num_layers = LimitSimulcastLayerCount(kMinLayers, kMaxLayers, 480, 250,
-                                        trials, webrtc::kVideoCodecVP8);
+                                        trials, kVideoCodecVP8);
   EXPECT_EQ(num_layers, 1u);
 }
 
@@ -366,7 +366,7 @@
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams = GetSimulcastConfig(
       CreateResolutions(/*max_width=*/960, /*max_height=*/540, kMaxLayers),
-      !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+      !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(240u, streams[0].width);
@@ -383,7 +383,7 @@
 
   std::vector<VideoStream> streams =
       GetSimulcastConfig(std::vector<Resolution>{{.width = 1, .height = 1}},
-                         !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+                         !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(1));
   EXPECT_EQ(1u, streams[0].width);
@@ -401,7 +401,7 @@
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams = GetSimulcastConfig(
       CreateResolutions(/*max_width=*/960, /*max_height=*/540, kMaxLayers),
-      !kScreenshare, true, trials, webrtc::kVideoCodecVP8);
+      !kScreenshare, true, trials, kVideoCodecVP8);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   EXPECT_EQ(240u, streams[0].width);
@@ -419,10 +419,10 @@
 };
 
 using BitrateLimitsTest =
-    TestWithParam<std::tuple<webrtc::VideoCodecType, BitrateLimitsTestParams>>;
+    TestWithParam<std::tuple<VideoCodecType, BitrateLimitsTestParams>>;
 
 TEST_P(BitrateLimitsTest, VerifyBitrateLimits) {
-  const auto codec_type = std::get<webrtc::VideoCodecType>(GetParam());
+  const auto codec_type = std::get<VideoCodecType>(GetParam());
   const auto test_params = std::get<BitrateLimitsTestParams>(GetParam());
   ExplicitKeyValueConfig trials("");
   std::vector<VideoStream> streams = GetSimulcastConfig(
@@ -442,7 +442,7 @@
 INSTANTIATE_TEST_SUITE_P(
     Vp8H264,
     BitrateLimitsTest,
-    Combine(Values(webrtc::kVideoCodecVP8, webrtc::kVideoCodecH264),
+    Combine(Values(kVideoCodecVP8, kVideoCodecH264),
             Values(BitrateLimitsTestParams{.width = 1920,
                                            .height = 1080,
                                            .expected_min_bitrate_kbps{150, 350,
@@ -460,8 +460,7 @@
                        .expected_min_bitrate_kbps{30, 150, 350},
                        .expected_max_bitrate_kbps{200, 450, 1200}})),
     [](const TestParamInfo<BitrateLimitsTest::ParamType>& info) {
-      return CodecTypeToPayloadString(
-                 std::get<webrtc::VideoCodecType>(info.param)) +
+      return CodecTypeToPayloadString(std::get<VideoCodecType>(info.param)) +
              std::to_string(
                  std::get<BitrateLimitsTestParams>(info.param).height);
     });
@@ -472,10 +471,10 @@
     Combine(
         Values(
 #ifdef RTC_ENABLE_H265
-            webrtc::kVideoCodecH265,
+            kVideoCodecH265,
 #endif
-            webrtc::kVideoCodecAV1,
-            webrtc::kVideoCodecVP9),
+            kVideoCodecAV1,
+            kVideoCodecVP9),
         Values(
             BitrateLimitsTestParams{.width = 1920,
                                     .height = 1080,
@@ -491,8 +490,7 @@
                 .expected_min_bitrate_kbps{30, 121, 337},
                 .expected_max_bitrate_kbps{101, 257, 879}})),
     [](const TestParamInfo<BitrateLimitsTest::ParamType>& info) {
-      return CodecTypeToPayloadString(
-                 std::get<webrtc::VideoCodecType>(info.param)) +
+      return CodecTypeToPayloadString(std::get<VideoCodecType>(info.param)) +
              std::to_string(
                  std::get<BitrateLimitsTestParams>(info.param).height);
     });
@@ -506,7 +504,7 @@
   const size_t kMaxLayers = 3;
   std::vector<VideoStream> streams =
       GetSimulcastConfig(CreateResolutions(1280, 720, kMaxLayers),
-                         !kScreenshare, true, trials, webrtc::kVideoCodecH265);
+                         !kScreenshare, true, trials, kVideoCodecH265);
 
   ASSERT_THAT(streams, SizeIs(kMaxLayers));
   for (size_t i = 0; i < streams.size(); ++i) {
diff --git a/video/corruption_detection/frame_instrumentation_generator_unittest.cc b/video/corruption_detection/frame_instrumentation_generator_unittest.cc
index d4362c0..fff4cb4 100644
--- a/video/corruption_detection/frame_instrumentation_generator_unittest.cc
+++ b/video/corruption_detection/frame_instrumentation_generator_unittest.cc
@@ -685,7 +685,7 @@
       VideoCodecType::kVideoCodecVP8);
 
   bool frames_destroyed[4] = {};
-  class TestBuffer : public webrtc::I420Buffer {
+  class TestBuffer : public I420Buffer {
    public:
     TestBuffer(int width, int height, bool* frame_destroyed_indicator)
         : I420Buffer(width, height),
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index d327a76..2f6ec09 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -327,7 +327,7 @@
 TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
   // If these fields trial are on, we get lower bitrates than expected by this
   // test, due to the packetization overhead and encoder pushback.
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       std::string(field_trial::GetFieldTrialString()) +
       "WebRTC-VideoRateControl/bitrate_adjuster:false/");
   class EncoderRateStatsTest : public test::EndToEndTest,
diff --git a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
index a8503d9..786535a 100644
--- a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
+++ b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
@@ -228,7 +228,7 @@
 };
 
 TEST_P(ResolutionBitrateLimitsTest, LimitsApplied) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:921600,"
       "min_start_bitrate_bps:0,"
@@ -272,7 +272,7 @@
 }
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        OneStreamLimitsAppliedForOneSpatialLayer) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:921600,"
       "min_start_bitrate_bps:0,"
@@ -291,7 +291,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        OneStreamLimitsNotAppliedForMultipleSpatialLayers) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -324,7 +324,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, IntersectionApplied) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:921600,"
       "min_start_bitrate_bps:0,"
@@ -343,7 +343,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, LimitsAppliedMiddleActive) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -360,7 +360,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, EncodingMinMaxBitrateAppliedMiddleActive) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -383,7 +383,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, MinBitrateNotAboveEncodingMax) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -404,7 +404,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, MaxBitrateNotBelowEncodingMin) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -464,7 +464,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, LimitsAppliedHighestActive) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -481,7 +481,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, EncodingMinMaxBitrateAppliedHighestActive) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -506,7 +506,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, LimitsNotAppliedLowestActive) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -527,7 +527,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        LimitsAppliedForVp9OneSpatialLayer) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -547,7 +547,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        LimitsNotAppliedForVp9MultipleSpatialLayers) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -570,7 +570,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        OneStreamLimitsAppliedForAv1OneSpatialLayer) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:921600,"
       "min_start_bitrate_bps:0,"
@@ -589,7 +589,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        LimitsAppliedForAv1SingleSpatialLayer) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -609,7 +609,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        EncodingMinMaxBitrateAppliedForAv1SingleSpatialLayer) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:921600,"
       "min_start_bitrate_bps:0,"
@@ -631,7 +631,7 @@
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        LimitsNotAppliedForAv1MultipleSpatialLayers) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
@@ -653,7 +653,7 @@
 }
 
 TEST_P(ResolutionBitrateLimitsTest, LimitsNotAppliedSimulcast) {
-  webrtc::test::ScopedFieldTrials field_trials(
+  test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
       "min_start_bitrate_bps:0|0,"
diff --git a/video/end_to_end_tests/rtp_rtcp_tests.cc b/video/end_to_end_tests/rtp_rtcp_tests.cc
index 712d4a8..1e0f1d7 100644
--- a/video/end_to_end_tests/rtp_rtcp_tests.cc
+++ b/video/end_to_end_tests/rtp_rtcp_tests.cc
@@ -362,7 +362,7 @@
         // to wait for a second for periodic Sender Report.
         rtcp::RapidResyncRequest force_send_sr_back_request;
         Buffer packet = force_send_sr_back_request.Build();
-        static_cast<webrtc::Transport*>(receive_transport_.get())
+        static_cast<Transport*>(receive_transport_.get())
             ->SendRtcp(packet, /*packet_options=*/{});
       }
       CreateFrameGeneratorCapturer(30, 1280, 720);
diff --git a/video/frame_cadence_adapter_unittest.cc b/video/frame_cadence_adapter_unittest.cc
index b40171e..285b917 100644
--- a/video/frame_cadence_adapter_unittest.cc
+++ b/video/frame_cadence_adapter_unittest.cc
@@ -1295,7 +1295,7 @@
 
 TEST_F(ZeroHertzQueueOverloadTest,
        QueueOverloadIsDisabledForZeroHerzWhenKillSwitchIsEnabled) {
-  webrtc::test::ScopedKeyValueConfig field_trials(
+  test::ScopedKeyValueConfig field_trials(
       field_trials_, "WebRTC-ZeroHertzQueueOverload/Disabled/");
   adapter_.reset();
   adapter_ = CreateAdapter(field_trials, time_controller_.GetClock());
diff --git a/video/frame_decode_timing.cc b/video/frame_decode_timing.cc
index 04b8e22..9871ba9 100644
--- a/video/frame_decode_timing.cc
+++ b/video/frame_decode_timing.cc
@@ -22,8 +22,7 @@
 
 namespace webrtc {
 
-FrameDecodeTiming::FrameDecodeTiming(Clock* clock,
-                                     webrtc::VCMTiming const* timing)
+FrameDecodeTiming::FrameDecodeTiming(Clock* clock, VCMTiming const* timing)
     : clock_(clock), timing_(timing) {
   RTC_DCHECK(clock_);
   RTC_DCHECK(timing_);
diff --git a/video/frame_decode_timing_unittest.cc b/video/frame_decode_timing_unittest.cc
index e4359b5..da7a098 100644
--- a/video/frame_decode_timing_unittest.cc
+++ b/video/frame_decode_timing_unittest.cc
@@ -35,10 +35,10 @@
 
 namespace {
 
-class FakeVCMTiming : public webrtc::VCMTiming {
+class FakeVCMTiming : public VCMTiming {
  public:
   explicit FakeVCMTiming(Clock* clock, const FieldTrialsView& field_trials)
-      : webrtc::VCMTiming(clock, field_trials) {}
+      : VCMTiming(clock, field_trials) {}
 
   Timestamp RenderTime(uint32_t frame_timestamp, Timestamp now) const override {
     RTC_DCHECK(render_time_map_.contains(frame_timestamp));
diff --git a/video/frame_encode_metadata_writer_unittest.cc b/video/frame_encode_metadata_writer_unittest.cc
index bb584b8..4580caa 100644
--- a/video/frame_encode_metadata_writer_unittest.cc
+++ b/video/frame_encode_metadata_writer_unittest.cc
@@ -386,8 +386,7 @@
   bitrate_allocation.SetBitrate(0, 0, 500000);
   encode_timer.OnSetRates(bitrate_allocation, 30);
 
-  webrtc::ColorSpace color_space =
-      CreateTestColorSpace(/*with_hdr_metadata=*/true);
+  ColorSpace color_space = CreateTestColorSpace(/*with_hdr_metadata=*/true);
   image.SetRtpTimestamp(static_cast<uint32_t>(kTimestampMs * 90));
   VideoFrame frame = VideoFrame::Builder()
                          .set_timestamp_ms(kTimestampMs)
diff --git a/video/full_stack_tests.cc b/video/full_stack_tests.cc
index 8245e6f..f8c809c 100644
--- a/video/full_stack_tests.cc
+++ b/video/full_stack_tests.cc
@@ -978,7 +978,7 @@
 #if !defined(WEBRTC_MAC)
 
 TEST(FullStackTest, Vp9ksvc_3sl_High) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
   auto fixture = CreateVideoQualityTestFixture();
   ParamsWithLogging simulcast;
@@ -993,7 +993,7 @@
 }
 
 TEST(FullStackTest, Vp9ksvc_3sl_Low) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
   auto fixture = CreateVideoQualityTestFixture();
   ParamsWithLogging simulcast;
@@ -1008,7 +1008,7 @@
 }
 
 TEST(FullStackTest, Vp9ksvc_3sl_Low_Bw_Limited) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
   auto fixture = CreateVideoQualityTestFixture();
   ParamsWithLogging simulcast;
@@ -1024,7 +1024,7 @@
 }
 
 TEST(FullStackTest, Vp9ksvc_3sl_Medium_Network_Restricted) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
   auto fixture = CreateVideoQualityTestFixture();
   ParamsWithLogging simulcast;
@@ -1042,7 +1042,7 @@
 
 // TODO(webrtc:9722): Remove when experiment is cleaned up.
 TEST(FullStackTest, Vp9ksvc_3sl_Medium_Network_Restricted_Trusted_Rate) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9IssueKeyFrameOnLayerDeactivation/Enabled/"));
   auto fixture = CreateVideoQualityTestFixture();
   ParamsWithLogging simulcast;
@@ -1087,7 +1087,7 @@
   simulcast.ss[0] = {
       streams, 2, 1, 0, InterLayerPredMode::kOn, std::vector<SpatialLayer>(),
       true};
-  webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(
+  test::ScopedFieldTrials override_trials(AppendFieldTrials(
       "WebRTC-ForceSimulatedOveruseIntervalMs/1000-50000-300/"));
   fixture->RunWithAnalyzer(simulcast);
 }
diff --git a/video/pc_full_stack_tests.cc b/video/pc_full_stack_tests.cc
index 841f961..f0c4c0e 100644
--- a/video/pc_full_stack_tests.cc
+++ b/video/pc_full_stack_tests.cc
@@ -39,14 +39,14 @@
 
 namespace webrtc {
 
-using ::webrtc::webrtc_pc_e2e::AudioConfig;
-using ::webrtc::webrtc_pc_e2e::EmulatedSFUConfig;
-using ::webrtc::webrtc_pc_e2e::PeerConfigurer;
-using ::webrtc::webrtc_pc_e2e::RunParams;
-using ::webrtc::webrtc_pc_e2e::ScreenShareConfig;
-using ::webrtc::webrtc_pc_e2e::VideoCodecConfig;
-using ::webrtc::webrtc_pc_e2e::VideoConfig;
-using ::webrtc::webrtc_pc_e2e::VideoSimulcastConfig;
+using webrtc_pc_e2e::AudioConfig;
+using webrtc_pc_e2e::EmulatedSFUConfig;
+using webrtc_pc_e2e::PeerConfigurer;
+using webrtc_pc_e2e::RunParams;
+using webrtc_pc_e2e::ScreenShareConfig;
+using webrtc_pc_e2e::VideoCodecConfig;
+using webrtc_pc_e2e::VideoConfig;
+using webrtc_pc_e2e::VideoSimulcastConfig;
 
 namespace {
 
@@ -1235,7 +1235,7 @@
 #if defined(RTC_ENABLE_VP9)
 
 TEST(PCFullStackTest, Pc_Screenshare_Slides_Vp9_3sl_High_Fps) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9InterLayerPred/"
                         "Enabled,inter_layer_pred_mode:on/"));
   std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
@@ -1269,7 +1269,7 @@
 }
 
 TEST(PCFullStackTest, Pc_Vp9svc_3sl_High) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9InterLayerPred/"
                         "Enabled,inter_layer_pred_mode:on/"));
   std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
@@ -1302,7 +1302,7 @@
 }
 
 TEST(PCFullStackTest, Pc_Vp9svc_3sl_Low) {
-  webrtc::test::ScopedFieldTrials override_trials(
+  test::ScopedFieldTrials override_trials(
       AppendFieldTrials("WebRTC-Vp9InterLayerPred/"
                         "Enabled,inter_layer_pred_mode:on/"));
   std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
@@ -1434,7 +1434,7 @@
 #define MAYBE_Pc_Simulcast_HD_High Pc_Simulcast_HD_High
 #endif
 TEST(PCFullStackTest, MAYBE_Pc_Simulcast_HD_High) {
-  webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(
+  test::ScopedFieldTrials override_trials(AppendFieldTrials(
       "WebRTC-ForceSimulatedOveruseIntervalMs/1000-50000-300/"));
   std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
       CreateNetworkEmulationManager();
diff --git a/video/receive_statistics_proxy.cc b/video/receive_statistics_proxy.cc
index 22d46e4..b89ae42 100644
--- a/video/receive_statistics_proxy.cc
+++ b/video/receive_statistics_proxy.cc
@@ -614,7 +614,7 @@
                                             VideoContentType content_type,
                                             VideoFrameType frame_type) {
   TimeDelta processing_delay = TimeDelta::Zero();
-  webrtc::Timestamp current_time = clock_->CurrentTime();
+  Timestamp current_time = clock_->CurrentTime();
   // TODO(bugs.webrtc.org/13984): some tests do not fill packet_infos().
   TimeDelta assembly_time = TimeDelta::Zero();
   if (frame.packet_infos().size() > 0) {
diff --git a/video/receive_statistics_proxy_unittest.cc b/video/receive_statistics_proxy_unittest.cc
index a198cd6..5e06231 100644
--- a/video/receive_statistics_proxy_unittest.cc
+++ b/video/receive_statistics_proxy_unittest.cc
@@ -128,7 +128,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesFramesDecoded) {
   EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (uint32_t i = 1; i <= 3; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                       VideoContentType::UNSPECIFIED,
@@ -141,7 +141,7 @@
   const Frequency kFps = Frequency::Hertz(20);
   const int kRequiredSamples =
       TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) * kFps;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (int i = 0; i < kRequiredSamples; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                       VideoContentType::UNSPECIFIED,
@@ -159,7 +159,7 @@
   const Frequency kFps = Frequency::Hertz(20);
   const int kRequiredSamples =
       TimeDelta::Seconds(metrics::kMinRunTimeInSeconds) * kFps;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (int i = 0; i < kRequiredSamples - 1; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                       VideoContentType::UNSPECIFIED,
@@ -174,7 +174,7 @@
 TEST_F(ReceiveStatisticsProxyTest,
        OnDecodedFrameWithQpDoesNotResetFramesDecodedOrTotalDecodeTime) {
   EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   TimeDelta expected_total_decode_time = TimeDelta::Zero();
   unsigned int expected_frames_decoded = 0;
   for (uint32_t i = 1; i <= 3; ++i) {
@@ -204,7 +204,7 @@
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesProcessingDelay) {
   const TimeDelta kProcessingDelay = TimeDelta::Millis(10);
   EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   TimeDelta expected_total_processing_delay = TimeDelta::Zero();
   unsigned int expected_frames_decoded = 0;
   // We set receive time fixed and increase the clock by 10ms
@@ -242,7 +242,7 @@
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesAssemblyTime) {
   const TimeDelta kAssemblyTime = TimeDelta::Millis(7);
   EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_decoded);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   TimeDelta expected_total_assembly_time = TimeDelta::Zero();
   unsigned int expected_frames_decoded = 0;
   unsigned int expected_frames_assembled_from_multiple_packets = 0;
@@ -316,7 +316,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesQpSum) {
   EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -329,7 +329,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameIncreasesTotalDecodeTime) {
   EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Millis(4),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -343,7 +343,7 @@
 TEST_F(ReceiveStatisticsProxyTest, ReportsContentType) {
   const std::string kRealtimeString("realtime");
   const std::string kScreenshareString("screen");
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   EXPECT_EQ(kRealtimeString, videocontenttypehelpers::ToString(
                                  statistics_proxy_->GetStats().content_type));
   statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Zero(),
@@ -359,7 +359,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, ReportsMaxInterframeDelay) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   const TimeDelta kInterframeDelay1 = TimeDelta::Millis(100);
   const TimeDelta kInterframeDelay2 = TimeDelta::Millis(200);
   const TimeDelta kInterframeDelay3 = TimeDelta::Millis(100);
@@ -390,7 +390,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, ReportInterframeDelayInWindow) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   const TimeDelta kInterframeDelay1 = TimeDelta::Millis(900);
   const TimeDelta kInterframeDelay2 = TimeDelta::Millis(750);
   const TimeDelta kInterframeDelay3 = TimeDelta::Millis(700);
@@ -428,7 +428,7 @@
   EXPECT_EQ(0u, stats.freeze_count);
   EXPECT_FALSE(stats.total_freezes_duration_ms);
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (size_t i = 0; i < VideoQualityObserver::kMinFrameSamplesToDetectFreeze;
        ++i) {
     time_controller_.AdvanceTime(TimeDelta::Millis(30));
@@ -449,7 +449,7 @@
   ASSERT_EQ(0u, stats.pause_count);
   ASSERT_EQ(0u, stats.total_pauses_duration_ms);
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnRenderedFrame(MetaData(frame));
 
   // Pause.
@@ -467,7 +467,7 @@
   ASSERT_EQ(0u, stats.pause_count);
   ASSERT_EQ(0u, stats.total_pauses_duration_ms);
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   // Pause -> Frame -> Pause
   time_controller_.AdvanceTime(TimeDelta::Seconds(5));
@@ -489,7 +489,7 @@
   VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0.0, stats.total_inter_frame_delay);
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   // Emulate delay before first frame is rendered. This is needed to ensure
   // that frame duration only covers time since first frame is rendered and
@@ -508,7 +508,7 @@
   VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   ASSERT_EQ(0.0, stats.total_squared_inter_frame_delay);
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (int i = 0; i <= 10; ++i) {
     time_controller_.AdvanceTime(TimeDelta::Millis(30));
     statistics_proxy_->OnRenderedFrame(MetaData(frame));
@@ -522,7 +522,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameWithoutQpQpSumWontExist) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
   statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
@@ -531,7 +531,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, OnDecodedFrameWithoutQpResetsQpSum) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   EXPECT_EQ(std::nullopt, statistics_proxy_->GetStats().qp_sum);
   statistics_proxy_->OnDecodedFrame(frame, 3u, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
@@ -545,7 +545,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest, OnRenderedFrameIncreasesFramesRendered) {
   EXPECT_EQ(0u, statistics_proxy_->GetStats().frames_rendered);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (uint32_t i = 1; i <= 3; ++i) {
     statistics_proxy_->OnRenderedFrame(MetaData(frame));
     EXPECT_EQ(i, statistics_proxy_->GetStats().frames_rendered);
@@ -695,7 +695,7 @@
 TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsFrameCounts) {
   const int kKeyFrames = 3;
   const int kDeltaFrames = 22;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   for (int i = 0; i < kKeyFrames; i++) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                       VideoContentType::UNSPECIFIED,
@@ -774,7 +774,7 @@
   time_controller_.AdvanceTime(kLifetime);
   // Need at least one decoded frame to report stream lifetime.
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnCompleteFrame(true, 1000, VideoContentType::UNSPECIFIED);
   statistics_proxy_->OnDecodedFrame(
       frame, std::nullopt, TimeDelta::Millis(1000),
@@ -920,7 +920,7 @@
        KeyFrameHistogramNotUpdatedForTooFewSamples) {
   const bool kIsKeyFrame = false;
   const int kFrameSizeBytes = 1000;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples - 1; ++i) {
     statistics_proxy_->OnCompleteFrame(kIsKeyFrame, kFrameSizeBytes,
@@ -945,7 +945,7 @@
        KeyFrameHistogramUpdatedForMinRequiredSamples) {
   const bool kIsKeyFrame = false;
   const int kFrameSizeBytes = 1000;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     statistics_proxy_->OnCompleteFrame(kIsKeyFrame, kFrameSizeBytes,
@@ -970,7 +970,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest, KeyFrameHistogramIsUpdated) {
   const int kFrameSizeBytes = 1000;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
@@ -1058,7 +1058,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest, DoesNotReportStaleFramerates) {
   const Frequency kDefaultFps = Frequency::Hertz(30);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kDefaultFps.hertz(); ++i) {
     // Since OnRenderedFrame is never called the fps in each sample will be 0,
@@ -1137,7 +1137,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, ZeroDelayReportedIfFrameNotDelayed) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -1160,7 +1160,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest,
        DelayedFrameHistogramsAreNotUpdatedIfMinRuntimeHasNotPassed) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -1182,7 +1182,7 @@
 
 TEST_F(ReceiveStatisticsProxyTest,
        DelayedFramesHistogramsAreNotUpdatedIfNoRenderedFrames) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -1199,7 +1199,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, DelayReportedIfFrameIsDelayed) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -1224,7 +1224,7 @@
 }
 
 TEST_F(ReceiveStatisticsProxyTest, AverageDelayOfDelayedFramesIsReported) {
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
   statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
                                     VideoContentType::UNSPECIFIED,
                                     VideoFrameType::kVideoFrameKey);
@@ -1342,7 +1342,7 @@
 TEST_P(ReceiveStatisticsProxyTestWithFreezeDuration, FreezeDetection) {
   VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
   EXPECT_EQ(0u, stats.freeze_count);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   // Add a very long frame. This is need to verify that average frame
   // duration, which is supposed to be calculated as mean of durations of
@@ -1364,9 +1364,9 @@
 
 class ReceiveStatisticsProxyTestWithContent
     : public ReceiveStatisticsProxyTest,
-      public ::testing::WithParamInterface<webrtc::VideoContentType> {
+      public ::testing::WithParamInterface<VideoContentType> {
  protected:
-  const webrtc::VideoContentType content_type_{GetParam()};
+  const VideoContentType content_type_{GetParam()};
 };
 
 INSTANTIATE_TEST_SUITE_P(ContentTypes,
@@ -1376,7 +1376,7 @@
 
 TEST_P(ReceiveStatisticsProxyTestWithContent, InterFrameDelaysAreReported) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1413,7 +1413,7 @@
        InterFrameDelaysPercentilesAreReported) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
   const int kLastFivePercentsSamples = kMinRequiredSamples * 5 / 100;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i <= kMinRequiredSamples - kLastFivePercentsSamples; ++i) {
     time_controller_.AdvanceTime(kInterFrameDelay);
@@ -1451,7 +1451,7 @@
 TEST_P(ReceiveStatisticsProxyTestWithContent,
        MaxInterFrameDelayOnlyWithValidAverage) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1475,7 +1475,7 @@
 
 TEST_P(ReceiveStatisticsProxyTestWithContent, MaxInterFrameDelayOnlyWithPause) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i <= kMinRequiredSamples; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1563,7 +1563,7 @@
   const TimeDelta kFreezeDelay = TimeDelta::Millis(200);
   const TimeDelta kCallDuration =
       kMinRequiredSamples * kInterFrameDelay + kFreezeDelay;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     VideoFrameMetaData meta = MetaData(frame);
@@ -1612,7 +1612,7 @@
   const TimeDelta kPauseDuration = TimeDelta::Seconds(10);
   const TimeDelta kCallDuration =
       kMinRequiredSamples * kFrameDuration + kFreezeDuration + kPauseDuration;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     time_controller_.AdvanceTime(kFrameDuration);
@@ -1661,7 +1661,7 @@
 TEST_P(ReceiveStatisticsProxyTestWithContent, PausesAreIgnored) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
   const TimeDelta kPauseDuration = TimeDelta::Seconds(10);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i <= kMinRequiredSamples; ++i) {
     VideoFrameMetaData meta = MetaData(frame);
@@ -1706,7 +1706,7 @@
 TEST_P(ReceiveStatisticsProxyTestWithContent, ManyPausesAtTheBeginning) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(33);
   const TimeDelta kPauseDuration = TimeDelta::Seconds(10);
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i <= kMinRequiredSamples; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, std::nullopt, TimeDelta::Zero(),
@@ -1736,8 +1736,8 @@
 
 TEST_P(ReceiveStatisticsProxyTestWithContent, TimeInHdReported) {
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(20);
-  webrtc::VideoFrame frame_hd = CreateFrame(1280, 720);
-  webrtc::VideoFrame frame_sd = CreateFrame(640, 360);
+  VideoFrame frame_hd = CreateFrame(1280, 720);
+  VideoFrame frame_sd = CreateFrame(640, 360);
 
   // HD frames.
   for (int i = 0; i < kMinRequiredSamples; ++i) {
@@ -1777,7 +1777,7 @@
   const TimeDelta kInterFrameDelay = TimeDelta::Millis(20);
   const int kHighQp = 80;
   const int kLowQp = 30;
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   // High quality frames.
   for (int i = 0; i < kMinRequiredSamples; ++i) {
@@ -1821,9 +1821,9 @@
   // To ensure long enough call duration.
   const TimeDelta kInterFrameDelay = TimeDelta::Seconds(2);
 
-  webrtc::VideoFrame frame_hd = CreateFrame(1280, 720);
-  webrtc::VideoFrame frame_sd = CreateFrame(640, 360);
-  webrtc::VideoFrame frame_ld = CreateFrame(320, 180);
+  VideoFrame frame_hd = CreateFrame(1280, 720);
+  VideoFrame frame_sd = CreateFrame(640, 360);
+  VideoFrame frame_ld = CreateFrame(320, 180);
 
   // Call once to pass content type.
   statistics_proxy_->OnDecodedFrame(frame_hd, std::nullopt, TimeDelta::Zero(),
@@ -1854,7 +1854,7 @@
   const int kLowQp = 30;
   const TimeDelta kDecodeTime = TimeDelta::Millis(7);
 
-  webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
+  VideoFrame frame = CreateFrame(kWidth, kHeight);
 
   for (int i = 0; i < kMinRequiredSamples; ++i) {
     statistics_proxy_->OnDecodedFrame(frame, kLowQp, kDecodeTime, content_type_,
diff --git a/video/rtp_video_stream_receiver2.cc b/video/rtp_video_stream_receiver2.cc
index bdd2cc2..3e41758 100644
--- a/video/rtp_video_stream_receiver2.cc
+++ b/video/rtp_video_stream_receiver2.cc
@@ -393,7 +393,7 @@
 void RtpVideoStreamReceiver2::AddReceiveCodec(
     uint8_t payload_type,
     VideoCodecType video_codec,
-    const webrtc::CodecParameterMap& codec_params,
+    const CodecParameterMap& codec_params,
     bool raw_payload) {
   RTC_DCHECK_RUN_ON(&packet_sequence_checker_);
   if (codec_params.count(kH264FmtpSpsPpsIdrInKeyframe) > 0 ||
diff --git a/video/rtp_video_stream_receiver2_unittest.cc b/video/rtp_video_stream_receiver2_unittest.cc
index 6a8f963..3440601 100644
--- a/video/rtp_video_stream_receiver2_unittest.cc
+++ b/video/rtp_video_stream_receiver2_unittest.cc
@@ -348,7 +348,7 @@
   received_packet_generator.SetColorSpace(kColorSpace);
 
   // Prepare the receiver for VP9.
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
                                               codec_params,
                                               /*raw_payload=*/false);
@@ -476,7 +476,7 @@
   const std::vector<uint8_t> kDeltaFramePayload = {5, 6, 7, 8, 9};
 
   // Prepare the receiver for VP9.
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
                                               codec_params,
                                               /*raw_payload=*/false);
@@ -553,7 +553,7 @@
   const std::vector<uint8_t> kDeltaFramePayload = {5, 6, 7, 8, 9};
 
   // Prepare the receiver for VP9.
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   rtp_video_stream_receiver_->AddReceiveCodec(kVp9PayloadType, kVideoCodecVP9,
                                               codec_params,
                                               /*raw_payload=*/false);
@@ -799,7 +799,7 @@
 
 TEST_P(RtpVideoStreamReceiver2TestH264, InBandSpsPps) {
   constexpr int kH264PayloadType = 98;
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   rtp_video_stream_receiver_->AddReceiveCodec(kH264PayloadType, kVideoCodecH264,
                                               codec_params,
                                               /*raw_payload=*/false);
@@ -856,7 +856,7 @@
 
 TEST_P(RtpVideoStreamReceiver2TestH264, OutOfBandFmtpSpsPps) {
   constexpr int kH264PayloadType = 99;
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   // Example parameter sets from https://tools.ietf.org/html/rfc3984#section-8.2
   // .
   codec_params.insert({kH264FmtpSpropParameterSets, "Z0IACpZTBYmI,aMljiA=="});
@@ -903,7 +903,7 @@
 }
 
 TEST_P(RtpVideoStreamReceiver2TestH264, ForceSpsPpsIdrIsKeyframe) {
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   // Forcing can be done either with field trial or codec_params.
   if (!env_.field_trials().IsEnabled("WebRTC-SpsPpsIdrIsH264Keyframe")) {
     codec_params.insert({kH264FmtpSpsPpsIdrInKeyframe, ""});
@@ -1063,7 +1063,7 @@
   rtp_packet_slice.Parse(raw_rtp_slice.data(), raw_rtp_slice.size());
 
   // Prepare the receiver for H264.
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   rtp_video_stream_receiver_->AddReceiveCodec(kH264PayloadType, kVideoCodecH264,
                                               codec_params, false);
   rtp_video_stream_receiver_->StartReceive();
@@ -1770,7 +1770,7 @@
 
 TEST_F(RtpVideoStreamReceiver2TestH265, H265Bitstream) {
   constexpr int kH265PayloadType = 98;
-  webrtc::CodecParameterMap codec_params;
+  CodecParameterMap codec_params;
   rtp_video_stream_receiver_->AddReceiveCodec(kH265PayloadType, kVideoCodecH265,
                                               codec_params,
                                               /*raw_payload=*/false);
diff --git a/video/send_statistics_proxy.cc b/video/send_statistics_proxy.cc
index 38873b4f..e6858df 100644
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@@ -147,7 +147,7 @@
 }
 
 std::optional<int> GetFallbackMaxPixelsIfFieldTrialEnabled(
-    const webrtc::FieldTrialsView& field_trials) {
+    const FieldTrialsView& field_trials) {
   std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
   return (absl::StartsWith(group, "Enabled"))
              ? GetFallbackMaxPixels(group.substr(7))
@@ -155,7 +155,7 @@
 }
 
 std::optional<int> GetFallbackMaxPixelsIfFieldTrialDisabled(
-    const webrtc::FieldTrialsView& field_trials) {
+    const FieldTrialsView& field_trials) {
   std::string group = field_trials.Lookup(kVp8ForcedFallbackEncoderFieldTrial);
   return (absl::StartsWith(group, "Disabled"))
              ? GetFallbackMaxPixels(group.substr(8))
diff --git a/video/video_analyzer.cc b/video/video_analyzer.cc
index 94f06ee..159bd8c 100644
--- a/video/video_analyzer.cc
+++ b/video/video_analyzer.cc
@@ -78,10 +78,10 @@
 namespace webrtc {
 namespace {
 
-using ::webrtc::test::GetGlobalMetricsLogger;
-using ::webrtc::test::ImprovementDirection;
-using ::webrtc::test::Metric;
-using ::webrtc::test::Unit;
+using test::GetGlobalMetricsLogger;
+using test::ImprovementDirection;
+using test::Metric;
+using test::Unit;
 
 constexpr TimeDelta kSendStatsPollingInterval = TimeDelta::Seconds(1);
 constexpr size_t kMaxComparisons = 10;
diff --git a/video/video_loopback.cc b/video/video_loopback.cc
index b8659d1..f2ab825 100644
--- a/video/video_loopback.cc
+++ b/video/video_loopback.cc
@@ -442,9 +442,9 @@
   // InitFieldTrialsFromString stores the char*, so the char array must outlive
   // the application.
   const std::string field_trials = absl::GetFlag(FLAGS_force_fieldtrials);
-  webrtc::field_trial::InitFieldTrialsFromString(field_trials.c_str());
+  field_trial::InitFieldTrialsFromString(field_trials.c_str());
 
-  webrtc::test::RunTest(webrtc::Loopback);
+  test::RunTest(Loopback);
   return 0;
 }
 }  // namespace webrtc
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 66a8a25..d4e1754 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -340,7 +340,7 @@
     const SdpVideoFormat& format) {
   std::unique_ptr<VideoDecoder> decoder;
   if (format.name == "FakeCodec") {
-    decoder = webrtc::FakeVideoDecoderFactory::CreateVideoDecoder();
+    decoder = FakeVideoDecoderFactory::CreateVideoDecoder();
   } else {
     decoder = decoder_factory_->Create(env, format);
   }
@@ -644,14 +644,14 @@
     const std::vector<std::string>& sl_descriptors) {
   if (params->ss[video_idx].streams.empty() &&
       params->ss[video_idx].infer_streams) {
-    webrtc::VideoEncoder::EncoderInfo encoder_info;
-    webrtc::VideoEncoderConfig encoder_config;
+    VideoEncoder::EncoderInfo encoder_info;
+    VideoEncoderConfig encoder_config;
     encoder_config.codec_type =
         PayloadStringToCodecType(params->video[video_idx].codec);
     encoder_config.content_type =
         params->screenshare[video_idx].enabled
-            ? webrtc::VideoEncoderConfig::ContentType::kScreen
-            : webrtc::VideoEncoderConfig::ContentType::kRealtimeVideo;
+            ? VideoEncoderConfig::ContentType::kScreen
+            : VideoEncoderConfig::ContentType::kRealtimeVideo;
     encoder_config.max_bitrate_bps = params->video[video_idx].max_bitrate_bps;
     encoder_config.min_transmit_bitrate_bps =
         params->video[video_idx].min_transmit_bps;
@@ -737,7 +737,7 @@
   RTC_CHECK(num_video_streams_ > 0);
   video_encoder_configs_.resize(num_video_streams_);
   std::string generic_codec_name;
-  webrtc::VideoEncoder::EncoderInfo encoder_info;
+  VideoEncoder::EncoderInfo encoder_info;
   for (size_t video_idx = 0; video_idx < num_video_streams_; ++video_idx) {
     VideoSendStream::Config config(send_transport);
     config.rtp.extmap_allow_mixed = true;
@@ -1423,7 +1423,7 @@
     // The real ADM requires extra initialization: setting default devices,
     // setting up number of channels etc. Helper class also calls
     // AudioDeviceModule::Init().
-    webrtc::adm_helpers::Init(audio_device.get());
+    adm_helpers::Init(audio_device.get());
   } else {
     audio_device->Init();
   }
@@ -1448,8 +1448,8 @@
 
   if (params_.call.send_side_bwe) {
     audio_send_config.rtp.extensions.push_back(
-        webrtc::RtpExtension(webrtc::RtpExtension::kTransportSequenceNumberUri,
-                             kTransportSequenceNumberExtensionId));
+        RtpExtension(RtpExtension::kTransportSequenceNumberUri,
+                     kTransportSequenceNumberExtensionId));
     audio_send_config.min_bitrate_bps = kOpusMinBitrateBps;
     audio_send_config.max_bitrate_bps = kOpusBitrateFbBps;
     // Only allow ANA when send-side BWE is enabled.
diff --git a/video/video_receive_stream2.cc b/video/video_receive_stream2.cc
index 3aced70..c7c1c30 100644
--- a/video/video_receive_stream2.cc
+++ b/video/video_receive_stream2.cc
@@ -132,11 +132,11 @@
     return buffer_;
   }
 
-  std::optional<webrtc::ColorSpace> color_space() const override {
+  std::optional<ColorSpace> color_space() const override {
     return color_space_;
   }
 
-  std::optional<webrtc::VideoRotation> video_rotation() const override {
+  std::optional<VideoRotation> video_rotation() const override {
     return video_rotation_;
   }
 
@@ -156,8 +156,8 @@
   VideoCodecType codec_;
   bool is_key_frame_;
   EncodedResolution resolution_;
-  std::optional<webrtc::ColorSpace> color_space_;
-  std::optional<webrtc::VideoRotation> video_rotation_;
+  std::optional<ColorSpace> color_space_;
+  std::optional<VideoRotation> video_rotation_;
 };
 
 RenderResolution InitialDecoderResolution(const FieldTrialsView& field_trials) {
@@ -174,21 +174,21 @@
 
 // Video decoder class to be used for unknown codecs. Doesn't support decoding
 // but logs messages to LS_ERROR.
-class NullVideoDecoder : public webrtc::VideoDecoder {
+class NullVideoDecoder : public VideoDecoder {
  public:
   bool Configure(const Settings& settings) override {
     RTC_LOG(LS_ERROR) << "Can't initialize NullVideoDecoder.";
     return true;
   }
 
-  int32_t Decode(const webrtc::EncodedImage& input_image,
+  int32_t Decode(const EncodedImage& input_image,
                  int64_t render_time_ms) override {
     RTC_LOG(LS_ERROR) << "The NullVideoDecoder doesn't support decoding.";
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   int32_t RegisterDecodeCompleteCallback(
-      webrtc::DecodedImageCallback* callback) override {
+      DecodedImageCallback* callback) override {
     RTC_LOG(LS_ERROR)
         << "Can't register decode complete callback on NullVideoDecoder.";
     return WEBRTC_VIDEO_CODEC_OK;
@@ -710,7 +710,7 @@
                                          frame_meta.decode_timestamp);
       }));
 
-  webrtc::MutexLock lock(&pending_resolution_mutex_);
+  MutexLock lock(&pending_resolution_mutex_);
   if (pending_resolution_.has_value()) {
     if (!pending_resolution_->empty() &&
         (video_frame.width() != static_cast<int>(pending_resolution_->width) ||
@@ -729,7 +729,7 @@
 }
 
 void VideoReceiveStream2::SetFrameDecryptor(
-    scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+    scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
   rtp_video_stream_receiver_.SetFrameDecryptor(std::move(frame_decryptor));
 }
 
@@ -973,7 +973,7 @@
       RTC_LOG(LS_ERROR) << "About to halt recordable encoded frame output due "
                            "to too many buffered frames.";
 
-    webrtc::MutexLock lock(&pending_resolution_mutex_);
+    MutexLock lock(&pending_resolution_mutex_);
     if (IsKeyFrameAndUnspecifiedResolution(*frame_ptr) &&
         !pending_resolution_.has_value())
       pending_resolution_.emplace();
@@ -1001,7 +1001,7 @@
     {
       // Fish out `pending_resolution_` to avoid taking the mutex on every lap
       // or dispatching under the mutex in the flush loop.
-      webrtc::MutexLock lock(&pending_resolution_mutex_);
+      MutexLock lock(&pending_resolution_mutex_);
       if (pending_resolution_.has_value())
         pending_resolution = *pending_resolution_;
     }
@@ -1134,7 +1134,7 @@
   }
 }
 
-std::vector<webrtc::RtpSource> VideoReceiveStream2::GetSources() const {
+std::vector<RtpSource> VideoReceiveStream2::GetSources() const {
   RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
   return source_tracker_.GetSources();
 }
diff --git a/video/video_receive_stream2_unittest.cc b/video/video_receive_stream2_unittest.cc
index 61e1872..b19e001 100644
--- a/video/video_receive_stream2_unittest.cc
+++ b/video/video_receive_stream2_unittest.cc
@@ -257,12 +257,10 @@
       video_receive_stream_ = nullptr;
     }
     timing_ = new VCMTiming(&env_.clock(), env_.field_trials());
-    video_receive_stream_ =
-        std::make_unique<webrtc::internal::VideoReceiveStream2>(
-            env_, &fake_call_, kDefaultNumCpuCores, &packet_router_,
-            config_.Copy(), &call_stats_, absl::WrapUnique(timing_),
-            &nack_periodic_processor_,
-            UseMetronome() ? &decode_sync_ : nullptr);
+    video_receive_stream_ = std::make_unique<internal::VideoReceiveStream2>(
+        env_, &fake_call_, kDefaultNumCpuCores, &packet_router_, config_.Copy(),
+        &call_stats_, absl::WrapUnique(timing_), &nack_periodic_processor_,
+        UseMetronome() ? &decode_sync_ : nullptr);
     video_receive_stream_->RegisterWithTransport(
         &rtp_stream_receiver_controller_);
     if (state)
@@ -283,7 +281,7 @@
   test::RtcpPacketParser rtcp_packet_parser_;
   PacketRouter packet_router_;
   RtpStreamReceiverController rtp_stream_receiver_controller_;
-  std::unique_ptr<webrtc::internal::VideoReceiveStream2> video_receive_stream_;
+  std::unique_ptr<internal::VideoReceiveStream2> video_receive_stream_;
   VCMTiming* timing_;
   test::FakeMetronome fake_metronome_;
   DecodeSynchronizer decode_sync_;
@@ -595,7 +593,7 @@
 }
 
 TEST_P(VideoReceiveStream2Test, PassesRotation) {
-  const webrtc::VideoRotation kRotation = webrtc::kVideoRotation_180;
+  const VideoRotation kRotation = kVideoRotation_180;
   std::unique_ptr<test::FakeEncodedFrame> test_frame =
       test::FakeFrameBuilder()
           .Id(0)
diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc
index 9f093f5..c0c8dff 100644
--- a/video/video_send_stream_impl.cc
+++ b/video/video_send_stream_impl.cc
@@ -228,10 +228,9 @@
                               const FieldTrialsView& field_trials) {
   int priority_bitrate = 0;
   if (PayloadStringToCodecType(codec_name) == VideoCodecType::kVideoCodecAV1) {
-    webrtc::FieldTrialParameter<int> av1_priority_bitrate("bitrate", 0);
-    webrtc::ParseFieldTrial(
-        {&av1_priority_bitrate},
-        field_trials.Lookup("WebRTC-AV1-OverridePriorityBitrate"));
+    FieldTrialParameter<int> av1_priority_bitrate("bitrate", 0);
+    ParseFieldTrial({&av1_priority_bitrate},
+                    field_trials.Lookup("WebRTC-AV1-OverridePriorityBitrate"));
     priority_bitrate = av1_priority_bitrate;
   }
   return priority_bitrate;
@@ -299,9 +298,8 @@
 VideoStreamEncoder::BitrateAllocationCallbackType
 GetBitrateAllocationCallbackType(const VideoSendStream::Config& config,
                                  const FieldTrialsView& field_trials) {
-  if (webrtc::RtpExtension::FindHeaderExtensionByUri(
-          config.rtp.extensions,
-          webrtc::RtpExtension::kVideoLayersAllocationUri,
+  if (RtpExtension::FindHeaderExtensionByUri(
+          config.rtp.extensions, RtpExtension::kVideoLayersAllocationUri,
           config.crypto_options.srtp.enable_encrypted_rtp_header_extensions
               ? RtpExtension::Filter::kPreferEncryptedExtension
               : RtpExtension::Filter::kDiscardEncryptedExtension)) {
@@ -349,7 +347,7 @@
     VideoStreamEncoder::BitrateAllocationCallbackType
         bitrate_allocation_callback_type,
     Metronome* metronome,
-    webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) {
+    VideoEncoderFactory::EncoderSelectorInterface* encoder_selector) {
   std::unique_ptr<TaskQueueBase, TaskQueueDeleter> encoder_queue =
       env.task_queue_factory().CreateTaskQueue(
           "EncoderQueue", TaskQueueFactory::Priority::NORMAL);
@@ -542,7 +540,7 @@
 }
 
 void VideoSendStreamImpl::SetSource(
-    VideoSourceInterface<webrtc::VideoFrame>* source,
+    VideoSourceInterface<VideoFrame>* source,
     const DegradationPreference& degradation_preference) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   video_stream_encoder_->SetSource(source, degradation_preference);
diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc
index 7a11b78..f0023f1 100644
--- a/video/video_send_stream_impl_unittest.cc
+++ b/video/video_send_stream_impl_unittest.cc
@@ -126,8 +126,7 @@
   MOCK_METHOD(void, SetEncodingData, (size_t, size_t, size_t), (override));
   MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>,
               GetSentRtpPacketInfos,
-              (uint32_t ssrc,
-               webrtc::ArrayView<const uint16_t> sequence_numbers),
+              (uint32_t ssrc, ArrayView<const uint16_t> sequence_numbers),
               (const, override));
 
   MOCK_METHOD(void, SetFecAllowed, (bool fec_allowed), (override));
@@ -217,7 +216,7 @@
 
  protected:
   GlobalSimulatedTimeController time_controller_;
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   NiceMock<MockTransport> transport_;
   NiceMock<MockRtpTransportControllerSend> transport_controller_;
   NiceMock<MockBitrateAllocator> bitrate_allocator_;
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 69e0c8e..d73601e 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -126,7 +126,7 @@
 namespace test {
 class VideoSendStreamPeer {
  public:
-  explicit VideoSendStreamPeer(webrtc::VideoSendStream* base_class_stream)
+  explicit VideoSendStreamPeer(VideoSendStream* base_class_stream)
       : internal_stream_(
             static_cast<internal::VideoSendStreamImpl*>(base_class_stream)) {}
   std::optional<float> GetPacingFactorOverride() const {
@@ -1754,8 +1754,8 @@
     }
 
    private:
-    webrtc::SequenceChecker module_process_thread_;
-    webrtc::SequenceChecker task_queue_thread_;
+    SequenceChecker module_process_thread_;
+    SequenceChecker task_queue_thread_;
     TaskQueueBase* const task_queue_;
     RtpHeaderExtensionMap extensions_;
     Call* call_ RTC_GUARDED_BY(task_queue_thread_);
@@ -1771,7 +1771,7 @@
   static const int kStartBitrateBps = 300000;
   static const int kRelayBandwidthCapBps = 800000;
   static const int kMinPacketsToSend = 100;
-  webrtc::test::ScopedKeyValueConfig field_trials(
+  test::ScopedKeyValueConfig field_trials(
       field_trials_, "WebRTC-Bwe-NetworkRouteConstraints/relay_cap:" +
                          std::to_string(kRelayBandwidthCapBps) + "bps/");
 
@@ -1858,8 +1858,8 @@
     }
 
    private:
-    webrtc::SequenceChecker module_process_thread_;
-    webrtc::SequenceChecker task_queue_thread_;
+    SequenceChecker module_process_thread_;
+    SequenceChecker task_queue_thread_;
     TaskQueueBase* const task_queue_;
     Call* call_ RTC_GUARDED_BY(task_queue_thread_);
     int packets_sent_ RTC_GUARDED_BY(task_queue_thread_);
@@ -2049,11 +2049,11 @@
   }
 
  private:
-  webrtc::SequenceChecker task_queue_thread_;
+  SequenceChecker task_queue_thread_;
   Call* call_ RTC_GUARDED_BY(task_queue_thread_) = nullptr;
   VideoSendStream::Config send_stream_config_{nullptr};
   VideoEncoderConfig encoder_config_;
-  webrtc::SequenceChecker module_process_thread_;
+  SequenceChecker module_process_thread_;
   uint32_t packets_sent_ RTC_GUARDED_BY(task_queue_thread_) = 0;
   bool running_without_padding_ RTC_GUARDED_BY(task_queue_thread_);
   T* const stream_resetter_;
@@ -2729,7 +2729,7 @@
   // TODO(bugs.webrtc.org/12058): If these fields trial are on, we get lower
   // bitrates than expected by this test, due to encoder pushback and subtracted
   // overhead.
-  webrtc::test::ScopedKeyValueConfig field_trials(
+  test::ScopedKeyValueConfig field_trials(
       field_trials_, "WebRTC-VideoRateControl/bitrate_adjuster:false/");
 
   class EncoderBitrateThresholdObserver : public test::SendTest,
@@ -2919,11 +2919,11 @@
 
     int num_rate_allocator_creations_;
     int num_encoder_initializations_;
-    webrtc::Call* call_;
-    webrtc::VideoSendStream* send_stream_;
+    Call* call_;
+    VideoSendStream* send_stream_;
     test::VideoEncoderProxyFactory encoder_factory_;
     std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
-    webrtc::VideoEncoderConfig encoder_config_;
+    VideoEncoderConfig encoder_config_;
   } test(env(), task_queue());
 
   RunBaseTest(&test);
@@ -3380,7 +3380,7 @@
   test::FunctionVideoEncoderFactory encoder_factory_;
   const Vp9TestParams params_;
   VideoCodecVP9 vp9_settings_;
-  webrtc::VideoEncoderConfig encoder_config_;
+  VideoEncoderConfig encoder_config_;
   bool last_packet_marker_ = false;
   std::optional<uint16_t> last_packet_sequence_number_;
   std::optional<uint32_t> last_packet_timestamp_;
@@ -3979,7 +3979,7 @@
           internal_send_peer.GetPacingFactorOverride().value_or(0.0f);
       float expected_pacing_factor = 1.1;  // Strict pacing factor.
       VideoSendStream::Stats stats = send_stream_->GetStats();
-      if (stats.content_type == webrtc::VideoContentType::SCREENSHARE) {
+      if (stats.content_type == VideoContentType::SCREENSHARE) {
         expected_pacing_factor = 1.0f;  // Currently used pacing factor in ALR.
       }
 
@@ -4123,7 +4123,7 @@
         VideoSendStream::Config* send_config,
         std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
         VideoEncoderConfig* encoder_config) override {
-      webrtc::VideoEncoder::EncoderInfo encoder_info;
+      VideoEncoder::EncoderInfo encoder_info;
       send_config->encoder_settings.encoder_factory = encoder_factory_;
       send_config->rtp.payload_name = payload_name_;
       send_config->rtp.payload_type =
diff --git a/video/video_source_sink_controller_unittest.cc b/video/video_source_sink_controller_unittest.cc
index bc4d263..603c726 100644
--- a/video/video_source_sink_controller_unittest.cc
+++ b/video/video_source_sink_controller_unittest.cc
@@ -43,13 +43,9 @@
 
   MOCK_METHOD(void,
               AddOrUpdateSink,
-              (webrtc::VideoSinkInterface<VideoFrame>*,
-               const webrtc::VideoSinkWants&),
+              (VideoSinkInterface<VideoFrame>*, const VideoSinkWants&),
               (override));
-  MOCK_METHOD(void,
-              RemoveSink,
-              (webrtc::VideoSinkInterface<VideoFrame>*),
-              (override));
+  MOCK_METHOD(void, RemoveSink, (VideoSinkInterface<VideoFrame>*), (override));
   MOCK_METHOD(void, RequestRefreshFrame, (), (override));
 };
 
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 8623944..212108e 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -346,9 +346,9 @@
         encoder_config.VP9().interLayerPred == InterLayerPredMode::kOn;
     layers_allocation.resolution_and_frame_rate_is_valid = true;
 
-    std::vector<DataRate> aggregated_spatial_bitrate(
-        webrtc::kMaxTemporalStreams, DataRate::Zero());
-    for (int si = 0; si < webrtc::kMaxSpatialLayers; ++si) {
+    std::vector<DataRate> aggregated_spatial_bitrate(kMaxTemporalStreams,
+                                                     DataRate::Zero());
+    for (int si = 0; si < kMaxSpatialLayers; ++si) {
       layers_allocation.resolution_and_frame_rate_is_valid = true;
       if (!target_bitrate.IsSpatialLayerUsed(si) ||
           target_bitrate.GetSpatialLayerSum(si) == 0) {
@@ -692,10 +692,9 @@
     const VideoStreamEncoderSettings& settings,
     std::unique_ptr<OveruseFrameDetector> overuse_detector,
     std::unique_ptr<FrameCadenceAdapterInterface> frame_cadence_adapter,
-    std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>
-        encoder_queue,
+    std::unique_ptr<TaskQueueBase, TaskQueueDeleter> encoder_queue,
     BitrateAllocationCallbackType allocation_cb_type,
-    webrtc::VideoEncoderFactory::EncoderSelectorInterface* encoder_selector)
+    VideoEncoderFactory::EncoderSelectorInterface* encoder_selector)
     : env_(env),
       worker_queue_(TaskQueueBase::Current()),
       number_of_cores_(number_of_cores),
@@ -1012,7 +1011,7 @@
 
       ReconfigureEncoder();
     } else {
-      webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
+      InvokeSetParametersCallback(callback, RTCError::OK());
     }
   });
 }
@@ -1485,7 +1484,7 @@
   stream_resource_manager_.ConfigureQualityScaler(info);
   stream_resource_manager_.ConfigureBandwidthQualityScaler(info);
 
-  webrtc::RTCError encoder_configuration_result = webrtc::RTCError::OK();
+  RTCError encoder_configuration_result = RTCError::OK();
 
   if (!encoder_initialized_) {
     RTC_LOG(LS_WARNING) << "Failed to initialize "
@@ -1497,14 +1496,13 @@
       RequestEncoderSwitch();
     } else {
       encoder_configuration_result =
-          webrtc::RTCError(RTCErrorType::UNSUPPORTED_OPERATION);
+          RTCError(RTCErrorType::UNSUPPORTED_OPERATION);
     }
   }
 
   if (!encoder_configuration_callbacks_.empty()) {
     for (auto& callback : encoder_configuration_callbacks_) {
-      webrtc::InvokeSetParametersCallback(callback,
-                                          encoder_configuration_result);
+      InvokeSetParametersCallback(callback, encoder_configuration_result);
     }
     encoder_configuration_callbacks_.clear();
   }