diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 344c4b4..1c4d634 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -77,9 +77,9 @@
 namespace {
 std::unique_ptr<voe::ChannelReceiveInterface> CreateChannelReceive(
     const Environment& env,
-    webrtc::AudioState* audio_state,
+    AudioState* audio_state,
     NetEqFactory* neteq_factory,
-    const webrtc::AudioReceiveStreamInterface::Config& config) {
+    const AudioReceiveStreamInterface::Config& config) {
   RTC_DCHECK(audio_state);
   internal::AudioState* internal_audio_state =
       static_cast<internal::AudioState*>(audio_state);
@@ -98,8 +98,8 @@
     const Environment& env,
     PacketRouter* packet_router,
     NetEqFactory* neteq_factory,
-    const webrtc::AudioReceiveStreamInterface::Config& config,
-    const scoped_refptr<webrtc::AudioState>& audio_state)
+    const AudioReceiveStreamInterface::Config& config,
+    const scoped_refptr<AudioState>& audio_state)
     : AudioReceiveStreamImpl(
           env,
           packet_router,
@@ -111,8 +111,8 @@
 AudioReceiveStreamImpl::AudioReceiveStreamImpl(
     const Environment& /* env */,
     PacketRouter* packet_router,
-    const webrtc::AudioReceiveStreamInterface::Config& config,
-    const scoped_refptr<webrtc::AudioState>& audio_state,
+    const AudioReceiveStreamInterface::Config& config,
+    const scoped_refptr<AudioState>& audio_state,
     std::unique_ptr<voe::ChannelReceiveInterface> channel_receive)
     : config_(config),
       audio_state_(audio_state),
@@ -159,7 +159,7 @@
 }
 
 void AudioReceiveStreamImpl::ReconfigureForTesting(
-    const webrtc::AudioReceiveStreamInterface::Config& config) {
+    const AudioReceiveStreamInterface::Config& config) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
 
   // SSRC can't be changed mid-stream.
@@ -212,7 +212,7 @@
 }
 
 void AudioReceiveStreamImpl::SetDepacketizerToDecoderFrameTransformer(
-    scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+    scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   channel_receive_->SetDepacketizerToDecoderFrameTransformer(
       std::move(frame_transformer));
@@ -238,7 +238,7 @@
   channel_receive_->SetNACKStatus(history_ms != 0, history_ms / 20);
 }
 
-void AudioReceiveStreamImpl::SetRtcpMode(webrtc::RtcpMode mode) {
+void AudioReceiveStreamImpl::SetRtcpMode(RtcpMode mode) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
 
   if (config_.rtp.rtcp_mode == mode)
@@ -255,17 +255,17 @@
 }
 
 void AudioReceiveStreamImpl::SetFrameDecryptor(
-    scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+    scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
   // TODO(bugs.webrtc.org/11993): This is called via WebRtcAudioReceiveStream,
   // expect to be called on the network thread.
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   channel_receive_->SetFrameDecryptor(std::move(frame_decryptor));
 }
 
-webrtc::AudioReceiveStreamInterface::Stats AudioReceiveStreamImpl::GetStats(
+AudioReceiveStreamInterface::Stats AudioReceiveStreamImpl::GetStats(
     bool get_and_clear_legacy_stats) const {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  webrtc::AudioReceiveStreamInterface::Stats stats;
+  AudioReceiveStreamInterface::Stats stats;
   stats.remote_ssrc = remote_ssrc();
 
   auto receive_codec = channel_receive_->GetReceiveCodec();
@@ -274,8 +274,7 @@
     stats.codec_payload_type = receive_codec->first;
   }
 
-  webrtc::CallReceiveStatistics call_stats =
-      channel_receive_->GetRTCPStatistics();
+  CallReceiveStatistics call_stats = channel_receive_->GetRTCPStatistics();
   stats.payload_bytes_received = call_stats.payload_bytes_received;
   stats.header_and_padding_bytes_received =
       call_stats.header_and_padding_bytes_received;
diff --git a/audio/audio_state_unittest.cc b/audio/audio_state_unittest.cc
index 0c278d7..6a98bdd 100644
--- a/audio/audio_state_unittest.cc
+++ b/audio/audio_state_unittest.cc
@@ -57,7 +57,7 @@
     std::unique_ptr<TaskQueueBase, TaskQueueDeleter> CreateTaskQueue(
         absl::string_view /* name */,
         Priority /* priority */) const override {
-      return std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>(
+      return std::unique_ptr<TaskQueueBase, TaskQueueDeleter>(
           new FakeTaskQueue());
     }
   };
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index cfbf843..832f86a 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -132,7 +132,7 @@
                  scoped_refptr<AudioDecoderFactory> decoder_factory,
                  std::optional<AudioCodecPairId> codec_pair_id,
                  scoped_refptr<FrameDecryptorInterface> frame_decryptor,
-                 const webrtc::CryptoOptions& crypto_options,
+                 const CryptoOptions& crypto_options,
                  scoped_refptr<FrameTransformerInterface> frame_transformer);
   ~ChannelReceive() override;
 
@@ -190,7 +190,7 @@
 
   CallReceiveStatistics GetRTCPStatistics() const override;
   void SetNACKStatus(bool enable, int max_packets) override;
-  void SetRtcpMode(webrtc::RtcpMode mode) override;
+  void SetRtcpMode(RtcpMode mode) override;
   void SetNonSenderRttMeasurement(bool enabled) override;
 
   AudioMixer::Source::AudioFrameInfo GetAudioFrameWithInfo(
@@ -204,11 +204,10 @@
   // Sets a frame transformer between the depacketizer and the decoder, to
   // transform the received frames before decoding them.
   void SetDepacketizerToDecoderFrameTransformer(
-      scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
-      override;
+      scoped_refptr<FrameTransformerInterface> frame_transformer) override;
 
   void SetFrameDecryptor(
-      scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) override;
+      scoped_refptr<FrameDecryptorInterface> frame_decryptor) override;
 
   void OnLocalSsrcChange(uint32_t local_ssrc) override;
 
@@ -233,7 +232,7 @@
       RTC_RUN_ON(worker_thread_checker_);
 
   void InitFrameTransformerDelegate(
-      scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
+      scoped_refptr<FrameTransformerInterface> frame_transformer)
       RTC_RUN_ON(worker_thread_checker_);
 
   // Thread checkers document and lock usage of some methods to specific threads
@@ -293,7 +292,7 @@
 
   mutable Mutex ts_stats_lock_;
 
-  webrtc::RtpTimestampUnwrapper rtp_ts_wraparound_handler_;
+  RtpTimestampUnwrapper rtp_ts_wraparound_handler_;
   // The rtp timestamp of the first played out audio frame.
   int64_t capture_start_rtp_time_stamp_;
   // The capture ntp time (in local timebase) of the first played out audio
@@ -310,12 +309,12 @@
   // E2EE Audio Frame Decryption
   scoped_refptr<FrameDecryptorInterface> frame_decryptor_
       RTC_GUARDED_BY(worker_thread_checker_);
-  webrtc::CryptoOptions crypto_options_;
+  CryptoOptions crypto_options_;
 
-  webrtc::AbsoluteCaptureTimeInterpolator absolute_capture_time_interpolator_
+  AbsoluteCaptureTimeInterpolator absolute_capture_time_interpolator_
       RTC_GUARDED_BY(worker_thread_checker_);
 
-  webrtc::CaptureClockOffsetUpdater capture_clock_offset_updater_
+  CaptureClockOffsetUpdater capture_clock_offset_updater_
       RTC_GUARDED_BY(ts_stats_lock_);
 
   scoped_refptr<ChannelReceiveFrameTransformerDelegate>
@@ -381,7 +380,7 @@
 }
 
 void ChannelReceive::InitFrameTransformerDelegate(
-    scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+    scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK(frame_transformer);
   RTC_DCHECK(!frame_transformer_delegate_);
   RTC_DCHECK(worker_thread_->IsCurrent());
@@ -565,7 +564,7 @@
     scoped_refptr<AudioDecoderFactory> decoder_factory,
     std::optional<AudioCodecPairId> codec_pair_id,
     scoped_refptr<FrameDecryptorInterface> frame_decryptor,
-    const webrtc::CryptoOptions& crypto_options,
+    const CryptoOptions& crypto_options,
     scoped_refptr<FrameTransformerInterface> frame_transformer)
     : env_(env),
       worker_thread_(TaskQueueBase::Current()),
@@ -713,14 +712,14 @@
   Buffer decrypted_audio_payload;
   if (frame_decryptor_ != nullptr) {
     const size_t max_plaintext_size = frame_decryptor_->GetMaxPlaintextByteSize(
-        webrtc::MediaType::AUDIO, payload_length);
+        MediaType::AUDIO, payload_length);
     decrypted_audio_payload.SetSize(max_plaintext_size);
 
     const std::vector<uint32_t> csrcs(header.arrOfCSRCs,
                                       header.arrOfCSRCs + header.numCSRCs);
     const FrameDecryptorInterface::Result decrypt_result =
         frame_decryptor_->Decrypt(
-            webrtc::MediaType::AUDIO, csrcs,
+            MediaType::AUDIO, csrcs,
             /*additional_data=*/
             nullptr, ArrayView<const uint8_t>(payload, payload_data_length),
             decrypted_audio_payload);
@@ -747,7 +746,7 @@
     char buf[1024];
     SimpleStringBuilder mime_type(buf);
     auto it = payload_type_map_.find(header.payloadType);
-    mime_type << webrtc::MediaTypeToString(webrtc::MediaType::AUDIO) << "/"
+    mime_type << MediaTypeToString(MediaType::AUDIO) << "/"
               << (it != payload_type_map_.end() ? it->second.name
                                                 : "x-unknown");
     frame_transformer_delegate_->Transform(payload_data, header, remote_ssrc_,
@@ -906,7 +905,7 @@
   }
 }
 
-void ChannelReceive::SetRtcpMode(webrtc::RtcpMode mode) {
+void ChannelReceive::SetRtcpMode(RtcpMode mode) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   rtp_rtcp_->SetRTCPStatus(mode);
 }
@@ -933,7 +932,7 @@
 }
 
 void ChannelReceive::SetDepacketizerToDecoderFrameTransformer(
-    scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+    scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   if (!frame_transformer) {
     RTC_DCHECK_NOTREACHED() << "Not setting the transformer?";
@@ -953,7 +952,7 @@
 }
 
 void ChannelReceive::SetFrameDecryptor(
-    scoped_refptr<webrtc::FrameDecryptorInterface> frame_decryptor) {
+    scoped_refptr<FrameDecryptorInterface> frame_decryptor) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   frame_decryptor_ = std::move(frame_decryptor);
 }
@@ -1189,7 +1188,7 @@
     scoped_refptr<AudioDecoderFactory> decoder_factory,
     std::optional<AudioCodecPairId> codec_pair_id,
     scoped_refptr<FrameDecryptorInterface> frame_decryptor,
-    const webrtc::CryptoOptions& crypto_options,
+    const CryptoOptions& crypto_options,
     scoped_refptr<FrameTransformerInterface> frame_transformer) {
   return std::make_unique<ChannelReceive>(
       env, neteq_factory, audio_device_module, rtcp_send_transport, local_ssrc,
diff --git a/audio/channel_receive_frame_transformer_delegate_unittest.cc b/audio/channel_receive_frame_transformer_delegate_unittest.cc
index 95bfd50..4b60ea2 100644
--- a/audio/channel_receive_frame_transformer_delegate_unittest.cc
+++ b/audio/channel_receive_frame_transformer_delegate_unittest.cc
@@ -42,7 +42,7 @@
  public:
   MOCK_METHOD(void,
               ReceiveFrame,
-              (webrtc::ArrayView<const uint8_t> packet,
+              (ArrayView<const uint8_t> packet,
                const RTPHeader& header,
                Timestamp receive_time));
 
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 52817f3..e953549 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -132,7 +132,7 @@
               Transport* rtp_transport,
               RtcpRttStats* rtcp_rtt_stats,
               FrameEncryptorInterface* frame_encryptor,
-              const webrtc::CryptoOptions& crypto_options,
+              const CryptoOptions& crypto_options,
               bool extmap_allow_mixed,
               int rtcp_report_interval_ms,
               uint32_t ssrc,
@@ -204,8 +204,7 @@
   // Sets a frame transformer between encoder and packetizer, to transform
   // encoded frames before sending them out the network.
   void SetEncoderToPacketizerFrameTransformer(
-      scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
-      override;
+      scoped_refptr<FrameTransformerInterface> frame_transformer) override;
 
   // RtcpPacketTypeCounterObserver.
   void RtcpPacketTypesCounterUpdated(
@@ -249,7 +248,7 @@
   void OnReceivedRtt(int64_t rtt_ms);
 
   void InitFrameTransformerDelegate(
-      scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer);
+      scoped_refptr<FrameTransformerInterface> frame_transformer);
 
   // Calls the encoder on the encoder queue (instead of blocking).
   void CallEncoderAsync(absl::AnyInvocable<void(AudioEncoder*)> modifier);
@@ -301,7 +300,7 @@
   scoped_refptr<FrameEncryptorInterface> frame_encryptor_
       RTC_GUARDED_BY(encoder_queue_checker_);
   // E2EE Frame Encryption Options
-  const webrtc::CryptoOptions crypto_options_;
+  const CryptoOptions crypto_options_;
 
   // Delegates calls to a frame transformer to transform audio, and
   // receives callbacks with the transformed frames; delegates calls to
@@ -389,7 +388,7 @@
     // is transformed, the delegate will call SendRtpAudio to send it.
     char buf[1024];
     SimpleStringBuilder mime_type(buf);
-    mime_type << webrtc::MediaTypeToString(webrtc::MediaType::AUDIO) << "/"
+    mime_type << MediaTypeToString(MediaType::AUDIO) << "/"
               << encoder_format_.name;
     frame_transformer_delegate_->Transform(
         frameType, payloadType, rtp_timestamp + rtp_rtcp_->StartTimestamp(),
@@ -421,13 +420,13 @@
       // TODO(benwright@webrtc.org) - Allocate enough to always encrypt inline.
       // Allocate a buffer to hold the maximum possible encrypted payload.
       size_t max_ciphertext_size = frame_encryptor_->GetMaxCiphertextByteSize(
-          webrtc::MediaType::AUDIO, payload.size());
+          MediaType::AUDIO, payload.size());
       encrypted_audio_payload.SetSize(max_ciphertext_size);
 
       // Encrypt the audio payload into the buffer.
       size_t bytes_written = 0;
       int encrypt_status =
-          frame_encryptor_->Encrypt(webrtc::MediaType::AUDIO, rtp_rtcp_->SSRC(),
+          frame_encryptor_->Encrypt(MediaType::AUDIO, rtp_rtcp_->SSRC(),
                                     /*additional_data=*/nullptr, payload,
                                     encrypted_audio_payload, &bytes_written);
       if (encrypt_status != 0) {
@@ -489,7 +488,7 @@
     Transport* rtp_transport,
     RtcpRttStats* rtcp_rtt_stats,
     FrameEncryptorInterface* frame_encryptor,
-    const webrtc::CryptoOptions& crypto_options,
+    const CryptoOptions& crypto_options,
     bool extmap_allow_mixed,
     int rtcp_report_interval_ms,
     uint32_t ssrc,
@@ -919,7 +918,7 @@
 }
 
 void ChannelSend::SetEncoderToPacketizerFrameTransformer(
-    scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+    scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   if (!frame_transformer)
     return;
@@ -937,7 +936,7 @@
 }
 
 void ChannelSend::InitFrameTransformerDelegate(
-    scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+    scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
   RTC_DCHECK(frame_transformer);
   RTC_DCHECK(!frame_transformer_delegate_);
@@ -971,7 +970,7 @@
     Transport* rtp_transport,
     RtcpRttStats* rtcp_rtt_stats,
     FrameEncryptorInterface* frame_encryptor,
-    const webrtc::CryptoOptions& crypto_options,
+    const CryptoOptions& crypto_options,
     bool extmap_allow_mixed,
     int rtcp_report_interval_ms,
     uint32_t ssrc,
diff --git a/audio/channel_send_frame_transformer_delegate_unittest.cc b/audio/channel_send_frame_transformer_delegate_unittest.cc
index 2a526f0..e9575c1 100644
--- a/audio/channel_send_frame_transformer_delegate_unittest.cc
+++ b/audio/channel_send_frame_transformer_delegate_unittest.cc
@@ -51,9 +51,9 @@
               (AudioFrameType frameType,
                uint8_t payloadType,
                uint32_t rtp_timestamp,
-               webrtc::ArrayView<const uint8_t> payload,
+               ArrayView<const uint8_t> payload,
                int64_t absolute_capture_timestamp_ms,
-               webrtc::ArrayView<const uint32_t> csrcs,
+               ArrayView<const uint32_t> csrcs,
                std::optional<uint8_t> audio_level_dbov));
 
   ChannelSendFrameTransformerDelegate::SendFrameCallback callback() {
@@ -104,7 +104,7 @@
       AudioFrameType::kEmptyFrame, 0, 0, mock_data, sizeof(mock_data), 0,
       /*ssrc=*/0, /*mimeType=*/"audio/opus", /*audio_level_dbov=*/123);
   return absl::WrapUnique(
-      static_cast<webrtc::TransformableAudioFrameInterface*>(frame.release()));
+      static_cast<TransformableAudioFrameInterface*>(frame.release()));
 }
 
 // Test that the delegate registers itself with the frame transformer on Init().
diff --git a/audio/channel_send_unittest.cc b/audio/channel_send_unittest.cc
index 03ce5bc..7636ee3 100644
--- a/audio/channel_send_unittest.cc
+++ b/audio/channel_send_unittest.cc
@@ -123,7 +123,7 @@
   void ProcessNextFrame() { ProcessNextFrame(CreateAudioFrame()); }
 
   GlobalSimulatedTimeController time_controller_;
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   Environment env_;
   NiceMock<MockTransport> transport_;
   CryptoOptions crypto_options_;
diff --git a/audio/test/audio_end_to_end_test.cc b/audio/test/audio_end_to_end_test.cc
index 746ae3f..d9c4594 100644
--- a/audio/test/audio_end_to_end_test.cc
+++ b/audio/test/audio_end_to_end_test.cc
@@ -63,8 +63,7 @@
     AudioSendStream::Config* send_config,
     std::vector<AudioReceiveStreamInterface::Config>* /* receive_configs */) {
   // Large bitrate by default.
-  const webrtc::SdpAudioFormat kDefaultFormat("opus", 48000, 2,
-                                              {{"stereo", "1"}});
+  const SdpAudioFormat kDefaultFormat("opus", 48000, 2, {{"stereo", "1"}});
   send_config->send_codec_spec = AudioSendStream::Config::SendCodecSpec(
       test::VideoTestConstants::kAudioSendPayloadType, kDefaultFormat);
   send_config->min_bitrate_bps = 32000;
diff --git a/audio/test/non_sender_rtt_test.cc b/audio/test/non_sender_rtt_test.cc
index 17dd97e..49b6cae 100644
--- a/audio/test/non_sender_rtt_test.cc
+++ b/audio/test/non_sender_rtt_test.cc
@@ -60,7 +60,7 @@
       // cases it can take more than 10 seconds.
       EXPECT_THAT(
           WaitUntil([&] { return HasRoundTripTimeMeasurement(); }, IsTrue(),
-                    {.timeout = webrtc::TimeDelta::Millis(kLongTimeoutMs)}),
+                    {.timeout = TimeDelta::Millis(kLongTimeoutMs)}),
           IsRtcOk());
     }