diff --git a/pc/audio_rtp_receiver.cc b/pc/audio_rtp_receiver.cc
index a8659de..6e7ca6d 100644
--- a/pc/audio_rtp_receiver.cc
+++ b/pc/audio_rtp_receiver.cc
@@ -278,7 +278,7 @@
 }
 
 void AudioRtpReceiver::SetDepacketizerToDecoderFrameTransformer(
-    rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer) {
+    rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) {
   RTC_DCHECK_RUN_ON(worker_thread_);
   if (media_channel_) {
     media_channel_->SetDepacketizerToDecoderFrameTransformer(
diff --git a/pc/audio_rtp_receiver.h b/pc/audio_rtp_receiver.h
index 86c42d5..36cbdff 100644
--- a/pc/audio_rtp_receiver.h
+++ b/pc/audio_rtp_receiver.h
@@ -118,8 +118,7 @@
   std::vector<RtpSource> GetSources() const override;
   int AttachmentId() const override { return attachment_id_; }
   void SetDepacketizerToDecoderFrameTransformer(
-      rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer)
-      override;
+      rtc::scoped_refptr<FrameTransformerInterface> frame_transformer) override;
 
  private:
   void RestartMediaChannel(absl::optional<uint32_t> ssrc)
diff --git a/pc/audio_rtp_receiver_unittest.cc b/pc/audio_rtp_receiver_unittest.cc
index 9eb20c9..e031f90 100644
--- a/pc/audio_rtp_receiver_unittest.cc
+++ b/pc/audio_rtp_receiver_unittest.cc
@@ -98,7 +98,7 @@
 // thread when a media channel pointer is passed to the receiver via the
 // constructor.
 TEST(AudioRtpReceiver, OnChangedNotificationsAfterConstruction) {
-  webrtc::test::RunLoop loop;
+  test::RunLoop loop;
   auto* thread = rtc::Thread::Current();  // Points to loop's thread.
   cricket::MockVoiceMediaReceiveChannelInterface receive_channel;
   auto receiver = rtc::make_ref_counted<AudioRtpReceiver>(
diff --git a/pc/audio_track.h b/pc/audio_track.h
index ae326b3..92c3141 100644
--- a/pc/audio_track.h
+++ b/pc/audio_track.h
@@ -58,7 +58,7 @@
 
  private:
   const rtc::scoped_refptr<AudioSourceInterface> audio_source_;
-  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker signaling_thread_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_checker_;
 };
 
 }  // namespace webrtc
diff --git a/pc/connection_context.h b/pc/connection_context.h
index 399e7c2..af5b7a9 100644
--- a/pc/connection_context.h
+++ b/pc/connection_context.h
@@ -138,7 +138,7 @@
       RTC_GUARDED_BY(signaling_thread_);
   std::unique_ptr<rtc::NetworkManager> default_network_manager_
       RTC_GUARDED_BY(signaling_thread_);
-  std::unique_ptr<webrtc::CallFactoryInterface> const call_factory_
+  std::unique_ptr<CallFactoryInterface> const call_factory_
       RTC_GUARDED_BY(worker_thread());
 
   std::unique_ptr<rtc::PacketSocketFactory> default_socket_factory_
diff --git a/pc/data_channel_controller_unittest.cc b/pc/data_channel_controller_unittest.cc
index 3b8adb6..7d4e604 100644
--- a/pc/data_channel_controller_unittest.cc
+++ b/pc/data_channel_controller_unittest.cc
@@ -27,7 +27,7 @@
 using ::testing::NiceMock;
 using ::testing::Return;
 
-class MockDataChannelTransport : public webrtc::DataChannelTransportInterface {
+class MockDataChannelTransport : public DataChannelTransportInterface {
  public:
   ~MockDataChannelTransport() override {}
 
diff --git a/pc/data_channel_integrationtest.cc b/pc/data_channel_integrationtest.cc
index faec76d..5a8004c 100644
--- a/pc/data_channel_integrationtest.cc
+++ b/pc/data_channel_integrationtest.cc
@@ -90,7 +90,7 @@
     // Some things use a time of "0" as a special value, so we need to start out
     // the fake clock at a nonzero time.
     // TODO(deadbeef): Fix this.
-    AdvanceTime(webrtc::TimeDelta::Seconds(1));
+    AdvanceTime(TimeDelta::Seconds(1));
   }
 
   // Explicit handle.
@@ -422,7 +422,7 @@
 TEST_P(DataChannelIntegrationTest, SctpDataChannelConfigSentToOtherSide) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
-  webrtc::DataChannelInit init;
+  DataChannelInit init;
   init.id = 53;
   init.maxRetransmits = 52;
   caller()->CreateDataChannel("data-channel", &init);
@@ -453,7 +453,7 @@
   // Normal procedure, but with unordered data channel config.
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
-  webrtc::DataChannelInit init;
+  DataChannelInit init;
   init.ordered = false;
   caller()->CreateDataChannel(&init);
   caller()->CreateAndSetAndSignalOffer();
@@ -515,7 +515,7 @@
   const size_t kIterations = 10;
   bool has_negotiated = false;
 
-  webrtc::DataChannelInit init;
+  DataChannelInit init;
   for (size_t repeats = 0; repeats < kIterations; ++repeats) {
     RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;
 
@@ -592,7 +592,7 @@
   const size_t kIterations = 10;
   bool has_negotiated = false;
 
-  webrtc::DataChannelInit init;
+  DataChannelInit init;
   for (size_t repeats = 0; repeats < kIterations; ++repeats) {
     RTC_LOG(LS_INFO) << "Iteration " << (repeats + 1) << "/" << kIterations;
 
diff --git a/pc/data_channel_unittest.cc b/pc/data_channel_unittest.cc
index 9b84a1b..a27a66c 100644
--- a/pc/data_channel_unittest.cc
+++ b/pc/data_channel_unittest.cc
@@ -81,8 +81,7 @@
         controller_(new FakeDataChannelController(&network_thread_)) {
     network_thread_.Start();
     inner_channel_ = controller_->CreateDataChannel("test", init_);
-    channel_ =
-        webrtc::SctpDataChannel::CreateProxy(inner_channel_, signaling_safety_);
+    channel_ = SctpDataChannel::CreateProxy(inner_channel_, signaling_safety_);
   }
   ~SctpDataChannelTest() override {
     run_loop_.Flush();
@@ -510,7 +509,7 @@
   SetChannelReady();
   InternalDataChannelInit init;
   init.id = 1;
-  auto dc = webrtc::SctpDataChannel::CreateProxy(
+  auto dc = SctpDataChannel::CreateProxy(
       controller_->CreateDataChannel("test1", init), signaling_safety_);
   EXPECT_EQ(DataChannelInterface::kOpen, dc->state());
 }
@@ -524,7 +523,7 @@
   init.ordered = false;
   rtc::scoped_refptr<SctpDataChannel> dc =
       controller_->CreateDataChannel("test1", init);
-  auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
+  auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
 
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
 
@@ -553,7 +552,7 @@
   init.ordered = false;
   rtc::scoped_refptr<SctpDataChannel> dc =
       controller_->CreateDataChannel("test1", init);
-  auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
+  auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
 
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
 
@@ -582,7 +581,7 @@
   init.ordered = false;
   rtc::scoped_refptr<SctpDataChannel> dc =
       controller_->CreateDataChannel("test1", init);
-  auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
+  auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
 
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
 
@@ -605,7 +604,7 @@
   init.ordered = false;
   rtc::scoped_refptr<SctpDataChannel> dc =
       controller_->CreateDataChannel("test1", init);
-  auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
+  auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
 
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
 
@@ -714,7 +713,7 @@
   SetChannelReady();
   rtc::scoped_refptr<SctpDataChannel> dc =
       controller_->CreateDataChannel("test1", config);
-  auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
+  auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
 
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
   EXPECT_EQ(0, controller_->last_sid());
@@ -779,7 +778,7 @@
   SetChannelReady();
   rtc::scoped_refptr<SctpDataChannel> dc =
       controller_->CreateDataChannel("test1", config);
-  auto proxy = webrtc::SctpDataChannel::CreateProxy(dc, signaling_safety_);
+  auto proxy = SctpDataChannel::CreateProxy(dc, signaling_safety_);
 
   EXPECT_EQ_WAIT(DataChannelInterface::kOpen, proxy->state(), 1000);
 
diff --git a/pc/ice_server_parsing_unittest.cc b/pc/ice_server_parsing_unittest.cc
index 4356b1e..a38638e 100644
--- a/pc/ice_server_parsing_unittest.cc
+++ b/pc/ice_server_parsing_unittest.cc
@@ -62,9 +62,7 @@
     server.tls_cert_policy = tls_certificate_policy;
     server.hostname = hostname;
     servers.push_back(server);
-    return webrtc::ParseIceServersOrError(servers, &stun_servers_,
-                                          &turn_servers_)
-        .ok();
+    return ParseIceServersOrError(servers, &stun_servers_, &turn_servers_).ok();
   }
 
  protected:
@@ -233,8 +231,7 @@
   server.password = "bar";
   servers.push_back(server);
   EXPECT_TRUE(
-      webrtc::ParseIceServersOrError(servers, &stun_servers_, &turn_servers_)
-          .ok());
+      ParseIceServersOrError(servers, &stun_servers_, &turn_servers_).ok());
   EXPECT_EQ(1U, stun_servers_.size());
   EXPECT_EQ(1U, turn_servers_.size());
 }
diff --git a/pc/ice_transport_unittest.cc b/pc/ice_transport_unittest.cc
index aaf9f2e..a42c107 100644
--- a/pc/ice_transport_unittest.cc
+++ b/pc/ice_transport_unittest.cc
@@ -32,7 +32,7 @@
 
   rtc::SocketServer* socket_server() const { return socket_server_.get(); }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
 
  private:
   std::unique_ptr<rtc::SocketServer> socket_server_;
diff --git a/pc/jsep_transport_controller.cc b/pc/jsep_transport_controller.cc
index 7c669a5..2a701cc 100644
--- a/pc/jsep_transport_controller.cc
+++ b/pc/jsep_transport_controller.cc
@@ -148,7 +148,7 @@
   return jsep_transport->rtcp_dtls_transport();
 }
 
-rtc::scoped_refptr<webrtc::DtlsTransport>
+rtc::scoped_refptr<DtlsTransport>
 JsepTransportController::LookupDtlsTransportByMid(const std::string& mid) {
   RTC_DCHECK_RUN_ON(network_thread_);
   auto jsep_transport = GetJsepTransportForMid(mid);
@@ -383,7 +383,7 @@
   return RTCError::OK();
 }
 
-rtc::scoped_refptr<webrtc::IceTransportInterface>
+rtc::scoped_refptr<IceTransportInterface>
 JsepTransportController::CreateIceTransport(const std::string& transport_name,
                                             bool rtcp) {
   int component = rtcp ? cricket::ICE_CANDIDATE_COMPONENT_RTCP
@@ -455,7 +455,7 @@
   return dtls;
 }
 
-std::unique_ptr<webrtc::RtpTransport>
+std::unique_ptr<RtpTransport>
 JsepTransportController::CreateUnencryptedRtpTransport(
     const std::string& transport_name,
     rtc::PacketTransportInternal* rtp_packet_transport,
@@ -470,13 +470,12 @@
   return unencrypted_rtp_transport;
 }
 
-std::unique_ptr<webrtc::SrtpTransport>
-JsepTransportController::CreateSdesTransport(
+std::unique_ptr<SrtpTransport> JsepTransportController::CreateSdesTransport(
     const std::string& transport_name,
     cricket::DtlsTransportInternal* rtp_dtls_transport,
     cricket::DtlsTransportInternal* rtcp_dtls_transport) {
   RTC_DCHECK_RUN_ON(network_thread_);
-  auto srtp_transport = std::make_unique<webrtc::SrtpTransport>(
+  auto srtp_transport = std::make_unique<SrtpTransport>(
       rtcp_dtls_transport == nullptr, *config_.field_trials);
   RTC_DCHECK(rtp_dtls_transport);
   srtp_transport->SetRtpPacketTransport(rtp_dtls_transport);
@@ -489,13 +488,13 @@
   return srtp_transport;
 }
 
-std::unique_ptr<webrtc::DtlsSrtpTransport>
+std::unique_ptr<DtlsSrtpTransport>
 JsepTransportController::CreateDtlsSrtpTransport(
     const std::string& transport_name,
     cricket::DtlsTransportInternal* rtp_dtls_transport,
     cricket::DtlsTransportInternal* rtcp_dtls_transport) {
   RTC_DCHECK_RUN_ON(network_thread_);
-  auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>(
+  auto dtls_srtp_transport = std::make_unique<DtlsSrtpTransport>(
       rtcp_dtls_transport == nullptr, *config_.field_trials);
   if (config_.enable_external_auth) {
     dtls_srtp_transport->EnableExternalAuth();
@@ -985,13 +984,12 @@
   const cricket::MediaContentDescription* content_desc =
       content_info.media_description();
 
-  const webrtc::RtpExtension* send_time_extension =
-      webrtc::RtpExtension::FindHeaderExtensionByUri(
-          content_desc->rtp_header_extensions(),
-          webrtc::RtpExtension::kAbsSendTimeUri,
+  const RtpExtension* send_time_extension =
+      RtpExtension::FindHeaderExtensionByUri(
+          content_desc->rtp_header_extensions(), RtpExtension::kAbsSendTimeUri,
           config_.crypto_options.srtp.enable_encrypted_rtp_header_extensions
-              ? webrtc::RtpExtension::kPreferEncryptedExtension
-              : webrtc::RtpExtension::kDiscardEncryptedExtension);
+              ? RtpExtension::kPreferEncryptedExtension
+              : RtpExtension::kDiscardEncryptedExtension);
   return send_time_extension ? send_time_extension->id : -1;
 }
 
@@ -1039,7 +1037,7 @@
                     "SDES and DTLS-SRTP cannot be enabled at the same time.");
   }
 
-  rtc::scoped_refptr<webrtc::IceTransportInterface> ice =
+  rtc::scoped_refptr<IceTransportInterface> ice =
       CreateIceTransport(content_info.name, /*rtcp=*/false);
 
   std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport =
@@ -1050,7 +1048,7 @@
   std::unique_ptr<SrtpTransport> sdes_transport;
   std::unique_ptr<DtlsSrtpTransport> dtls_srtp_transport;
 
-  rtc::scoped_refptr<webrtc::IceTransportInterface> rtcp_ice;
+  rtc::scoped_refptr<IceTransportInterface> rtcp_ice;
   if (config_.rtcp_mux_policy !=
           PeerConnectionInterface::kRtcpMuxPolicyRequire &&
       content_info.type == cricket::MediaProtocolType::kRtp) {
@@ -1096,7 +1094,7 @@
         OnRtcpPacketReceived_n(buffer, packet_time_ms);
       });
   jsep_transport->rtp_transport()->SetUnDemuxableRtpPacketReceivedHandler(
-      [this](webrtc::RtpPacketReceived& packet) {
+      [this](RtpPacketReceived& packet) {
         RTC_DCHECK_RUN_ON(network_thread_);
         OnUnDemuxableRtpPacketReceived_n(packet);
       });
@@ -1421,7 +1419,7 @@
 }
 
 void JsepTransportController::OnUnDemuxableRtpPacketReceived_n(
-    const webrtc::RtpPacketReceived& packet) {
+    const RtpPacketReceived& packet) {
   RTC_DCHECK(config_.un_demuxable_packet_handler);
   config_.un_demuxable_packet_handler(packet);
 }
diff --git a/pc/jsep_transport_controller.h b/pc/jsep_transport_controller.h
index 5880e34..8f9b9c8 100644
--- a/pc/jsep_transport_controller.h
+++ b/pc/jsep_transport_controller.h
@@ -112,7 +112,7 @@
     rtc::SSLProtocolVersion ssl_max_version = rtc::SSL_PROTOCOL_DTLS_12;
     // `crypto_options` is used to determine if created DTLS transports
     // negotiate GCM crypto suites or not.
-    webrtc::CryptoOptions crypto_options;
+    CryptoOptions crypto_options;
     PeerConnectionInterface::BundlePolicy bundle_policy =
         PeerConnectionInterface::kBundlePolicyBalanced;
     PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy =
@@ -120,7 +120,7 @@
     bool disable_encryption = false;
     bool enable_external_auth = false;
     // Used to inject the ICE/DTLS transports created externally.
-    webrtc::IceTransportFactory* ice_transport_factory = nullptr;
+    IceTransportFactory* ice_transport_factory = nullptr;
     cricket::DtlsTransportFactory* dtls_transport_factory = nullptr;
     Observer* transport_observer = nullptr;
     // Must be provided and valid for the lifetime of the
@@ -140,7 +140,7 @@
     std::function<void(rtc::SSLHandshakeError)> on_dtls_handshake_error_;
 
     // Field trials.
-    const webrtc::FieldTrialsView* field_trials;
+    const FieldTrialsView* field_trials;
   };
 
   // The ICE related events are fired on the `network_thread`.
@@ -174,7 +174,7 @@
   const cricket::DtlsTransportInternal* GetRtcpDtlsTransport(
       const std::string& mid) const;
   // Gets the externally sharable version of the DtlsTransport.
-  rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid(
+  rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
       const std::string& mid);
   rtc::scoped_refptr<SctpTransport> GetSctpTransport(
       const std::string& mid) const;
@@ -399,19 +399,19 @@
   std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
       const cricket::ContentInfo& content_info,
       cricket::IceTransportInternal* ice);
-  rtc::scoped_refptr<webrtc::IceTransportInterface> CreateIceTransport(
+  rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
       const std::string& transport_name,
       bool rtcp);
 
-  std::unique_ptr<webrtc::RtpTransport> CreateUnencryptedRtpTransport(
+  std::unique_ptr<RtpTransport> CreateUnencryptedRtpTransport(
       const std::string& transport_name,
       rtc::PacketTransportInternal* rtp_packet_transport,
       rtc::PacketTransportInternal* rtcp_packet_transport);
-  std::unique_ptr<webrtc::SrtpTransport> CreateSdesTransport(
+  std::unique_ptr<SrtpTransport> CreateSdesTransport(
       const std::string& transport_name,
       cricket::DtlsTransportInternal* rtp_dtls_transport,
       cricket::DtlsTransportInternal* rtcp_dtls_transport);
-  std::unique_ptr<webrtc::DtlsSrtpTransport> CreateDtlsSrtpTransport(
+  std::unique_ptr<DtlsSrtpTransport> CreateDtlsSrtpTransport(
       const std::string& transport_name,
       cricket::DtlsTransportInternal* rtp_dtls_transport,
       cricket::DtlsTransportInternal* rtcp_dtls_transport);
@@ -453,7 +453,7 @@
   void OnRtcpPacketReceived_n(rtc::CopyOnWriteBuffer* packet,
                               int64_t packet_time_us)
       RTC_RUN_ON(network_thread_);
-  void OnUnDemuxableRtpPacketReceived_n(const webrtc::RtpPacketReceived& packet)
+  void OnUnDemuxableRtpPacketReceived_n(const RtpPacketReceived& packet)
       RTC_RUN_ON(network_thread_);
 
   void OnDtlsHandshakeError(rtc::SSLHandshakeError error);
diff --git a/pc/jsep_transport_controller_unittest.cc b/pc/jsep_transport_controller_unittest.cc
index faa8842..f5e258c 100644
--- a/pc/jsep_transport_controller_unittest.cc
+++ b/pc/jsep_transport_controller_unittest.cc
@@ -56,7 +56,7 @@
 
 namespace webrtc {
 
-class FakeIceTransportFactory : public webrtc::IceTransportFactory {
+class FakeIceTransportFactory : public IceTransportFactory {
  public:
   ~FakeIceTransportFactory() override = default;
   rtc::scoped_refptr<IceTransportInterface> CreateIceTransport(
@@ -72,7 +72,7 @@
  public:
   std::unique_ptr<cricket::DtlsTransportInternal> CreateDtlsTransport(
       cricket::IceTransportInternal* ice,
-      const webrtc::CryptoOptions& crypto_options,
+      const CryptoOptions& crypto_options,
       rtc::SSLProtocolVersion max_version) override {
     return std::make_unique<FakeDtlsTransport>(
         static_cast<cricket::FakeIceTransport*>(ice));
@@ -379,7 +379,7 @@
   // Transport controller needs to be destroyed first, because it may issue
   // callbacks that modify the changed_*_by_mid in the destructor.
   std::unique_ptr<JsepTransportController> transport_controller_;
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
 };
 
 TEST_F(JsepTransportControllerTest, GetRtpTransport) {
@@ -425,7 +425,7 @@
   // and verify that the resulting container is empty.
   auto dtls_transport =
       transport_controller_->LookupDtlsTransportByMid(kVideoMid1);
-  webrtc::DtlsTransport* my_transport =
+  DtlsTransport* my_transport =
       static_cast<DtlsTransport*>(dtls_transport.get());
   EXPECT_NE(nullptr, my_transport->internal());
   transport_controller_.reset();
@@ -899,7 +899,7 @@
       transport_controller_->GetDtlsTransport(kAudioMid1));
   fake_audio_dtls->fake_ice_transport()->MaybeStartGathering();
   fake_audio_dtls->fake_ice_transport()->SetTransportState(
-      webrtc::IceTransportState::kChecking,
+      IceTransportState::kChecking,
       cricket::IceTransportState::STATE_CONNECTING);
   EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionChecking,
                  ice_connection_state_, kTimeout);
diff --git a/pc/legacy_stats_collector.cc b/pc/legacy_stats_collector.cc
index 3bc65ee..98b7cb9 100644
--- a/pc/legacy_stats_collector.cc
+++ b/pc/legacy_stats_collector.cc
@@ -355,9 +355,8 @@
   report->AddInt64(StatsReport::kStatsValueNameInterframeDelayMaxMs,
                    info.interframe_delay_max_ms);
 
-  report->AddString(
-      StatsReport::kStatsValueNameContentType,
-      webrtc::videocontenttypehelpers::ToString(info.content_type));
+  report->AddString(StatsReport::kStatsValueNameContentType,
+                    videocontenttypehelpers::ToString(info.content_type));
 }
 
 void ExtractStats(const cricket::VideoSenderInfo& info,
@@ -398,9 +397,8 @@
   for (const auto& i : ints)
     report->AddInt(i.name, i.value);
   report->AddString(StatsReport::kStatsValueNameMediaType, "video");
-  report->AddString(
-      StatsReport::kStatsValueNameContentType,
-      webrtc::videocontenttypehelpers::ToString(info.content_type));
+  report->AddString(StatsReport::kStatsValueNameContentType,
+                    videocontenttypehelpers::ToString(info.content_type));
 }
 
 void ExtractStats(const cricket::BandwidthEstimationInfo& info,
@@ -1033,7 +1031,7 @@
   if (pc_->signaling_state() == PeerConnectionInterface::kClosed)
     return;
 
-  webrtc::Call::Stats call_stats = pc_->GetCallStats();
+  Call::Stats call_stats = pc_->GetCallStats();
   cricket::BandwidthEstimationInfo bwe_info;
   bwe_info.available_send_bandwidth = call_stats.send_bandwidth_bps;
   bwe_info.available_recv_bandwidth = call_stats.recv_bandwidth_bps;
diff --git a/pc/legacy_stats_collector.h b/pc/legacy_stats_collector.h
index e905b39..1c7aad0 100644
--- a/pc/legacy_stats_collector.h
+++ b/pc/legacy_stats_collector.h
@@ -177,9 +177,9 @@
   void ExtractMediaInfo(
       const std::map<std::string, std::string>& transport_names_by_mid);
   void ExtractSenderInfo();
-  webrtc::StatsReport* GetReport(const StatsReport::StatsType& type,
-                                 const std::string& id,
-                                 StatsReport::Direction direction);
+  StatsReport* GetReport(const StatsReport::StatsType& type,
+                         const std::string& id,
+                         StatsReport::Direction direction);
 
   // Helper method to get stats from the local audio tracks.
   void UpdateStatsFromExistingLocalAudioTracks(bool has_remote_tracks);
diff --git a/pc/media_stream_unittest.cc b/pc/media_stream_unittest.cc
index f55ea20..d6c79ef 100644
--- a/pc/media_stream_unittest.cc
+++ b/pc/media_stream_unittest.cc
@@ -91,7 +91,7 @@
   ASSERT_EQ(1u, stream_->GetAudioTracks().size());
 
   // Verify the video track.
-  scoped_refptr<webrtc::MediaStreamTrackInterface> video_track(
+  scoped_refptr<MediaStreamTrackInterface> video_track(
       stream_->GetVideoTracks()[0]);
   EXPECT_EQ(0, video_track->id().compare(kVideoTrackId));
   EXPECT_TRUE(video_track->enabled());
@@ -105,7 +105,7 @@
   EXPECT_TRUE(video_track->enabled());
 
   // Verify the audio track.
-  scoped_refptr<webrtc::MediaStreamTrackInterface> audio_track(
+  scoped_refptr<MediaStreamTrackInterface> audio_track(
       stream_->GetAudioTracks()[0]);
   EXPECT_EQ(0, audio_track->id().compare(kAudioTrackId));
   EXPECT_TRUE(audio_track->enabled());
@@ -139,14 +139,12 @@
 }
 
 TEST_F(MediaStreamTest, ChangeVideoTrack) {
-  scoped_refptr<webrtc::VideoTrackInterface> video_track(
-      stream_->GetVideoTracks()[0]);
+  scoped_refptr<VideoTrackInterface> video_track(stream_->GetVideoTracks()[0]);
   ChangeTrack(video_track.get());
 }
 
 TEST_F(MediaStreamTest, ChangeAudioTrack) {
-  scoped_refptr<webrtc::AudioTrackInterface> audio_track(
-      stream_->GetAudioTracks()[0]);
+  scoped_refptr<AudioTrackInterface> audio_track(stream_->GetAudioTracks()[0]);
   ChangeTrack(audio_track.get());
 }
 
diff --git a/pc/peer_connection.cc b/pc/peer_connection.cc
index 183cbeb..46c28bb 100644
--- a/pc/peer_connection.cc
+++ b/pc/peer_connection.cc
@@ -185,7 +185,7 @@
 absl::optional<int> RTCConfigurationToIceConfigOptionalInt(
     int rtc_configuration_parameter) {
   if (rtc_configuration_parameter ==
-      webrtc::PeerConnectionInterface::RTCConfiguration::kUndefined) {
+      PeerConnectionInterface::RTCConfiguration::kUndefined) {
     return absl::nullopt;
   }
   return rtc_configuration_parameter;
@@ -449,7 +449,7 @@
     absl::optional<int> ice_unwritable_min_checks;
     absl::optional<int> ice_inactive_timeout;
     absl::optional<int> stun_candidate_keepalive_interval;
-    webrtc::TurnCustomizer* turn_customizer;
+    TurnCustomizer* turn_customizer;
     SdpSemantics sdp_semantics;
     absl::optional<rtc::AdapterType> network_preference;
     bool active_reset_srtp_params;
@@ -459,7 +459,7 @@
     bool enable_implicit_rollback;
     absl::optional<int> report_usage_pattern_delay_ms;
     absl::optional<int> stable_writable_connection_ping_interval_ms;
-    webrtc::VpnPreference vpn_preference;
+    VpnPreference vpn_preference;
     std::vector<rtc::NetworkMask> vpn_list;
     PortAllocatorConfig port_allocator_config;
     absl::optional<TimeDelta> pacer_burst_interval;
@@ -1685,7 +1685,7 @@
     std::function<void(RTCError)> callback) {
   RTC_DCHECK_RUN_ON(signaling_thread());
   sdp_handler_->AddIceCandidate(std::move(candidate),
-                                [this, callback](webrtc::RTCError result) {
+                                [this, callback](RTCError result) {
                                   ClearStatsCache();
                                   callback(result);
                                 });
@@ -1789,7 +1789,7 @@
     std::unique_ptr<RtcEventLogOutput> output) {
   int64_t output_period_ms = 5000;
   if (trials().IsDisabled("WebRTC-RtcEventLogNewFormat")) {
-    output_period_ms = webrtc::RtcEventLog::kImmediateOutput;
+    output_period_ms = RtcEventLog::kImmediateOutput;
   }
   return StartRtcEventLog(std::move(output), output_period_ms);
 }
@@ -2222,7 +2222,7 @@
     IceTransportsType type,
     int candidate_pool_size,
     PortPrunePolicy turn_port_prune_policy,
-    webrtc::TurnCustomizer* turn_customizer,
+    TurnCustomizer* turn_customizer,
     absl::optional<int> stun_candidate_keepalive_interval,
     bool have_local_description) {
   RTC_DCHECK_RUN_ON(network_thread());
diff --git a/pc/peer_connection.h b/pc/peer_connection.h
index ea1a9d9..a345089 100644
--- a/pc/peer_connection.h
+++ b/pc/peer_connection.h
@@ -163,7 +163,7 @@
       const DataChannelInit* config) override;
   // WARNING: LEGACY. See peerconnectioninterface.h
   bool GetStats(StatsObserver* observer,
-                webrtc::MediaStreamTrackInterface* track,
+                MediaStreamTrackInterface* track,
                 StatsOutputLevel level) override;
   // Spec-complaint GetStats(). See peerconnectioninterface.h
   void GetStats(RTCStatsCollectorCallback* callback) override;
@@ -510,7 +510,7 @@
       IceTransportsType type,
       int candidate_pool_size,
       PortPrunePolicy turn_port_prune_policy,
-      webrtc::TurnCustomizer* turn_customizer,
+      TurnCustomizer* turn_customizer,
       absl::optional<int> stun_candidate_keepalive_interval,
       bool have_local_description);
 
@@ -602,7 +602,7 @@
   // a) Specified in PeerConnectionDependencies (owned).
   // b) Accessed via ConnectionContext (e.g PeerConnectionFactoryDependencies>
   // c) Created as Default (FieldTrialBasedConfig).
-  const webrtc::AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig>
+  const AlwaysValidPointer<const FieldTrialsView, FieldTrialBasedConfig>
       trials_;
   const PeerConnectionFactoryInterface::Options options_;
   PeerConnectionObserver* observer_ RTC_GUARDED_BY(signaling_thread()) =
@@ -634,7 +634,7 @@
   std::unique_ptr<cricket::PortAllocator>
       port_allocator_;  // TODO(bugs.webrtc.org/9987): Accessed on both
                         // signaling and network thread.
-  const std::unique_ptr<webrtc::IceTransportFactory>
+  const std::unique_ptr<IceTransportFactory>
       ice_transport_factory_;  // TODO(bugs.webrtc.org/9987): Accessed on the
                                // signaling thread but the underlying raw
                                // pointer is given to
diff --git a/pc/peer_connection_crypto_unittest.cc b/pc/peer_connection_crypto_unittest.cc
index dc350b2..a65988a 100644
--- a/pc/peer_connection_crypto_unittest.cc
+++ b/pc/peer_connection_crypto_unittest.cc
@@ -162,7 +162,7 @@
     return transport_info->description.connection_role;
   }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::AutoSocketServerThread main_;
   rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
diff --git a/pc/peer_connection_encodings_integrationtest.cc b/pc/peer_connection_encodings_integrationtest.cc
index c7181c5..ae23867 100644
--- a/pc/peer_connection_encodings_integrationtest.cc
+++ b/pc/peer_connection_encodings_integrationtest.cc
@@ -77,18 +77,17 @@
 // RTX, RED and FEC are reliability mechanisms used in combinations with other
 // codecs, but are not themselves a specific codec. Typically you don't want to
 // filter these out of the list of codec preferences.
-bool IsReliabilityMechanism(const webrtc::RtpCodecCapability& codec) {
+bool IsReliabilityMechanism(const RtpCodecCapability& codec) {
   return absl::EqualsIgnoreCase(codec.name, cricket::kRtxCodecName) ||
          absl::EqualsIgnoreCase(codec.name, cricket::kRedCodecName) ||
          absl::EqualsIgnoreCase(codec.name, cricket::kUlpfecCodecName);
 }
 
 std::string GetCurrentCodecMimeType(
-    rtc::scoped_refptr<const webrtc::RTCStatsReport> report,
-    const webrtc::RTCOutboundRtpStreamStats& outbound_rtp) {
+    rtc::scoped_refptr<const RTCStatsReport> report,
+    const RTCOutboundRtpStreamStats& outbound_rtp) {
   return outbound_rtp.codec_id.is_defined()
-             ? *report->GetAs<webrtc::RTCCodecStats>(*outbound_rtp.codec_id)
-                    ->mime_type
+             ? *report->GetAs<RTCCodecStats>(*outbound_rtp.codec_id)->mime_type
              : "";
 }
 
@@ -98,8 +97,8 @@
   uint32_t height;
 };
 
-const webrtc::RTCOutboundRtpStreamStats* FindOutboundRtpByRid(
-    const std::vector<const webrtc::RTCOutboundRtpStreamStats*>& outbound_rtps,
+const RTCOutboundRtpStreamStats* FindOutboundRtpByRid(
+    const std::vector<const RTCOutboundRtpStreamStats*>& outbound_rtps,
     const absl::string_view& rid) {
   for (const auto* outbound_rtp : outbound_rtps) {
     if (outbound_rtp->rid.is_defined() && *outbound_rtp->rid == rid) {
@@ -121,8 +120,8 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> CreatePc() {
     auto pc_wrapper = rtc::make_ref_counted<PeerConnectionTestWrapper>(
         "pc", &pss_, background_thread_.get(), background_thread_.get());
-    pc_wrapper->CreatePc({}, webrtc::CreateBuiltinAudioEncoderFactory(),
-                         webrtc::CreateBuiltinAudioDecoderFactory());
+    pc_wrapper->CreatePc({}, CreateBuiltinAudioEncoderFactory(),
+                         CreateBuiltinAudioDecoderFactory());
     return pc_wrapper;
   }
 
@@ -130,10 +129,9 @@
       rtc::scoped_refptr<PeerConnectionTestWrapper> local,
       rtc::scoped_refptr<PeerConnectionTestWrapper> remote,
       std::vector<cricket::SimulcastLayer> init_layers) {
-    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
-        local->GetUserMedia(
-            /*audio=*/false, cricket::AudioOptions(), /*video=*/true,
-            {.width = 1280, .height = 720});
+    rtc::scoped_refptr<MediaStreamInterface> stream = local->GetUserMedia(
+        /*audio=*/false, cricket::AudioOptions(), /*video=*/true,
+        {.width = 1280, .height = 720});
     rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
 
     RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>>
@@ -973,8 +971,7 @@
       local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_AUDIO);
   rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
       transceiver_or_error.MoveValue();
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   EXPECT_FALSE(parameters.encodings[0].codec.has_value());
 }
 
@@ -986,8 +983,7 @@
       local_pc_wrapper->pc()->AddTransceiver(cricket::MEDIA_TYPE_VIDEO);
   rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
       transceiver_or_error.MoveValue();
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   EXPECT_FALSE(parameters.encodings[0].codec.has_value());
 }
 
@@ -997,19 +993,19 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<MediaStreamInterface> stream =
       local_pc_wrapper->GetUserMedia(
           /*audio=*/true, {}, /*video=*/false, {});
   rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
 
-  absl::optional<webrtc::RtpCodecCapability> pcmu =
+  absl::optional<RtpCodecCapability> pcmu =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "pcmu");
   ASSERT_TRUE(pcmu);
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = pcmu;
   init.send_encodings.push_back(encoding_parameters);
 
@@ -1017,8 +1013,7 @@
       local_pc_wrapper->pc()->AddTransceiver(track, init);
   rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
       transceiver_or_error.MoveValue();
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   EXPECT_EQ(*parameters.encodings[0].codec, *pcmu);
 
   NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@@ -1039,19 +1034,19 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<MediaStreamInterface> stream =
       local_pc_wrapper->GetUserMedia(
           /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
   rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
 
-  absl::optional<webrtc::RtpCodecCapability> vp9 =
+  absl::optional<RtpCodecCapability> vp9 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp9");
   ASSERT_TRUE(vp9);
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = vp9;
   encoding_parameters.scalability_mode = "L3T3";
   init.send_encodings.push_back(encoding_parameters);
@@ -1060,8 +1055,7 @@
       local_pc_wrapper->pc()->AddTransceiver(track, init);
   rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
       transceiver_or_error.MoveValue();
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   EXPECT_EQ(*parameters.encodings[0].codec, *vp9);
 
   NegotiateWithSimulcastTweaks(local_pc_wrapper, remote_pc_wrapper);
@@ -1087,20 +1081,19 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<MediaStreamInterface> stream =
       local_pc_wrapper->GetUserMedia(
           /*audio=*/true, {}, /*video=*/false, {});
   rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
 
-  absl::optional<webrtc::RtpCodecCapability> pcmu =
+  absl::optional<RtpCodecCapability> pcmu =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "pcmu");
 
   auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
   rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
       transceiver_or_error.MoveValue();
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = pcmu;
   EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok());
 
@@ -1125,12 +1118,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<MediaStreamInterface> stream =
       local_pc_wrapper->GetUserMedia(
           /*audio=*/true, {}, /*video=*/false, {});
   rtc::scoped_refptr<AudioTrackInterface> track = stream->GetAudioTracks()[0];
 
-  absl::optional<webrtc::RtpCodecCapability> pcmu =
+  absl::optional<RtpCodecCapability> pcmu =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "pcmu");
 
@@ -1150,8 +1143,7 @@
   EXPECT_STRCASENE(("audio/" + pcmu->name).c_str(), codec_name.c_str());
   std::string last_codec_id = outbound_rtps[0]->codec_id.value();
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = pcmu;
   EXPECT_TRUE(audio_transceiver->sender()->SetParameters(parameters).ok());
 
@@ -1174,20 +1166,19 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<MediaStreamInterface> stream =
       local_pc_wrapper->GetUserMedia(
           /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
   rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
 
-  absl::optional<webrtc::RtpCodecCapability> vp9 =
+  absl::optional<RtpCodecCapability> vp9 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp9");
 
   auto transceiver_or_error = local_pc_wrapper->pc()->AddTransceiver(track);
   rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
       transceiver_or_error.MoveValue();
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = vp9;
   parameters.encodings[0].scalability_mode = "L3T3";
   EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok());
@@ -1218,12 +1209,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
+  rtc::scoped_refptr<MediaStreamInterface> stream =
       local_pc_wrapper->GetUserMedia(
           /*audio=*/false, {}, /*video=*/true, {.width = 1280, .height = 720});
   rtc::scoped_refptr<VideoTrackInterface> track = stream->GetVideoTracks()[0];
 
-  absl::optional<webrtc::RtpCodecCapability> vp9 =
+  absl::optional<RtpCodecCapability> vp9 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp9");
 
@@ -1243,8 +1234,7 @@
   EXPECT_STRCASENE(("audio/" + vp9->name).c_str(), codec_name.c_str());
   std::string last_codec_id = outbound_rtps[0]->codec_id.value();
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = vp9;
   parameters.encodings[0].scalability_mode = "L3T3";
   EXPECT_TRUE(video_transceiver->sender()->SetParameters(parameters).ok());
@@ -1269,15 +1259,15 @@
        AddTransceiverRejectsUnknownCodecParameterAudio) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  webrtc::RtpCodec dummy_codec;
+  RtpCodec dummy_codec;
   dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO;
   dummy_codec.name = "FOOBAR";
   dummy_codec.clock_rate = 90000;
   dummy_codec.num_channels = 2;
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = dummy_codec;
   init.send_encodings.push_back(encoding_parameters);
 
@@ -1292,14 +1282,14 @@
        AddTransceiverRejectsUnknownCodecParameterVideo) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  webrtc::RtpCodec dummy_codec;
+  RtpCodec dummy_codec;
   dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO;
   dummy_codec.name = "FOOBAR";
   dummy_codec.clock_rate = 90000;
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = dummy_codec;
   init.send_encodings.push_back(encoding_parameters);
 
@@ -1314,7 +1304,7 @@
        SetParametersRejectsUnknownCodecParameterAudio) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  webrtc::RtpCodec dummy_codec;
+  RtpCodec dummy_codec;
   dummy_codec.kind = cricket::MEDIA_TYPE_AUDIO;
   dummy_codec.name = "FOOBAR";
   dummy_codec.clock_rate = 90000;
@@ -1326,8 +1316,7 @@
   rtc::scoped_refptr<RtpTransceiverInterface> audio_transceiver =
       transceiver_or_error.MoveValue();
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = dummy_codec;
   RTCError error = audio_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1337,7 +1326,7 @@
        SetParametersRejectsUnknownCodecParameterVideo) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  webrtc::RtpCodec dummy_codec;
+  RtpCodec dummy_codec;
   dummy_codec.kind = cricket::MEDIA_TYPE_VIDEO;
   dummy_codec.name = "FOOBAR";
   dummy_codec.clock_rate = 90000;
@@ -1348,8 +1337,7 @@
   rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
       transceiver_or_error.MoveValue();
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = dummy_codec;
   RTCError error = video_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1359,12 +1347,12 @@
        SetParametersRejectsNonPreferredCodecParameterAudio) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  absl::optional<webrtc::RtpCodecCapability> opus =
+  absl::optional<RtpCodecCapability> opus =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "opus");
   ASSERT_TRUE(opus);
 
-  std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
+  std::vector<RtpCodecCapability> not_opus_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
           .codecs;
@@ -1382,8 +1370,7 @@
       transceiver_or_error.MoveValue();
   ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = opus;
   RTCError error = audio_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1393,12 +1380,12 @@
        SetParametersRejectsNonPreferredCodecParameterVideo) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  absl::optional<webrtc::RtpCodecCapability> vp8 =
+  absl::optional<RtpCodecCapability> vp8 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp8");
   ASSERT_TRUE(vp8);
 
-  std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
+  std::vector<RtpCodecCapability> not_vp8_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
           .codecs;
@@ -1416,8 +1403,7 @@
       transceiver_or_error.MoveValue();
   ASSERT_TRUE(video_transceiver->SetCodecPreferences(not_vp8_codecs).ok());
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = vp8;
   RTCError error = video_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1429,12 +1415,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> opus =
+  absl::optional<RtpCodecCapability> opus =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "opus");
   ASSERT_TRUE(opus);
 
-  std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
+  std::vector<RtpCodecCapability> not_opus_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
           .codecs;
@@ -1456,8 +1442,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = opus;
   RTCError error = audio_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1469,12 +1454,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> opus =
+  absl::optional<RtpCodecCapability> opus =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "opus");
   ASSERT_TRUE(opus);
 
-  std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
+  std::vector<RtpCodecCapability> not_opus_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
           .codecs;
@@ -1519,8 +1504,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = opus;
   RTCError error = audio_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1532,12 +1516,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> vp8 =
+  absl::optional<RtpCodecCapability> vp8 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp8");
   ASSERT_TRUE(vp8);
 
-  std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
+  std::vector<RtpCodecCapability> not_vp8_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
           .codecs;
@@ -1559,8 +1543,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = vp8;
   RTCError error = video_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1572,12 +1555,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> vp8 =
+  absl::optional<RtpCodecCapability> vp8 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp8");
   ASSERT_TRUE(vp8);
 
-  std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
+  std::vector<RtpCodecCapability> not_vp8_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
           .codecs;
@@ -1622,8 +1605,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].codec = vp8;
   RTCError error = video_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1635,12 +1617,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> opus =
+  absl::optional<RtpCodecCapability> opus =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "opus");
   ASSERT_TRUE(opus);
 
-  std::vector<webrtc::RtpCodecCapability> not_opus_codecs =
+  std::vector<RtpCodecCapability> not_opus_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
           .codecs;
@@ -1651,9 +1633,9 @@
                      }),
       not_opus_codecs.end());
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = opus;
   init.send_encodings.push_back(encoding_parameters);
 
@@ -1667,8 +1649,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   EXPECT_EQ(parameters.encodings[0].codec, opus);
 
   ASSERT_TRUE(audio_transceiver->SetCodecPreferences(not_opus_codecs).ok());
@@ -1684,24 +1665,24 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  std::vector<webrtc::RtpCodecCapability> send_codecs =
+  std::vector<RtpCodecCapability> send_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
           .codecs;
 
-  absl::optional<webrtc::RtpCodecCapability> opus =
+  absl::optional<RtpCodecCapability> opus =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "opus");
   ASSERT_TRUE(opus);
 
-  absl::optional<webrtc::RtpCodecCapability> red =
+  absl::optional<RtpCodecCapability> red =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_AUDIO,
                                                    "red");
   ASSERT_TRUE(red);
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = opus;
   init.send_encodings.push_back(encoding_parameters);
 
@@ -1720,8 +1701,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      audio_transceiver->sender()->GetParameters();
+  RtpParameters parameters = audio_transceiver->sender()->GetParameters();
   EXPECT_EQ(parameters.encodings[0].codec, opus);
   EXPECT_EQ(parameters.codecs[0].payload_type, red->preferred_payload_type);
   EXPECT_EQ(parameters.codecs[0].name, red->name);
@@ -1743,14 +1723,14 @@
        SetParametersRejectsScalabilityModeForSelectedCodec) {
   rtc::scoped_refptr<PeerConnectionTestWrapper> local_pc_wrapper = CreatePc();
 
-  absl::optional<webrtc::RtpCodecCapability> vp8 =
+  absl::optional<RtpCodecCapability> vp8 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp8");
   ASSERT_TRUE(vp8);
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.codec = vp8;
   encoding_parameters.scalability_mode = "L1T3";
   init.send_encodings.push_back(encoding_parameters);
@@ -1761,8 +1741,7 @@
   rtc::scoped_refptr<RtpTransceiverInterface> video_transceiver =
       transceiver_or_error.MoveValue();
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   parameters.encodings[0].scalability_mode = "L3T3";
   RTCError error = video_transceiver->sender()->SetParameters(parameters);
   EXPECT_EQ(error.type(), RTCErrorType::INVALID_MODIFICATION);
@@ -1774,12 +1753,12 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> vp8 =
+  absl::optional<RtpCodecCapability> vp8 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp8");
   ASSERT_TRUE(vp8);
 
-  std::vector<webrtc::RtpCodecCapability> not_vp8_codecs =
+  std::vector<RtpCodecCapability> not_vp8_codecs =
       local_pc_wrapper->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
           .codecs;
@@ -1790,9 +1769,9 @@
                      }),
       not_vp8_codecs.end());
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.rid = "h";
   encoding_parameters.codec = vp8;
   encoding_parameters.scale_resolution_down_by = 2;
@@ -1811,8 +1790,7 @@
   local_pc_wrapper->WaitForConnection();
   remote_pc_wrapper->WaitForConnection();
 
-  webrtc::RtpParameters parameters =
-      video_transceiver->sender()->GetParameters();
+  RtpParameters parameters = video_transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 2u);
   EXPECT_EQ(parameters.encodings[0].codec, vp8);
   EXPECT_EQ(parameters.encodings[1].codec, vp8);
@@ -1833,17 +1811,17 @@
   rtc::scoped_refptr<PeerConnectionTestWrapper> remote_pc_wrapper = CreatePc();
   ExchangeIceCandidates(local_pc_wrapper, remote_pc_wrapper);
 
-  absl::optional<webrtc::RtpCodecCapability> vp8 =
+  absl::optional<RtpCodecCapability> vp8 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp8");
   ASSERT_TRUE(vp8);
-  absl::optional<webrtc::RtpCodecCapability> vp9 =
+  absl::optional<RtpCodecCapability> vp9 =
       local_pc_wrapper->FindFirstSendCodecWithName(cricket::MEDIA_TYPE_VIDEO,
                                                    "vp9");
 
-  webrtc::RtpTransceiverInit init;
-  init.direction = webrtc::RtpTransceiverDirection::kSendOnly;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  init.direction = RtpTransceiverDirection::kSendOnly;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.rid = "h";
   encoding_parameters.codec = vp8;
   encoding_parameters.scale_resolution_down_by = 2;
diff --git a/pc/peer_connection_factory_proxy.h b/pc/peer_connection_factory_proxy.h
index 4781497..b9bd1cb 100644
--- a/pc/peer_connection_factory_proxy.h
+++ b/pc/peer_connection_factory_proxy.h
@@ -29,10 +29,10 @@
               CreatePeerConnectionOrError,
               const PeerConnectionInterface::RTCConfiguration&,
               PeerConnectionDependencies)
-PROXY_CONSTMETHOD1(webrtc::RtpCapabilities,
+PROXY_CONSTMETHOD1(RtpCapabilities,
                    GetRtpSenderCapabilities,
                    cricket::MediaType)
-PROXY_CONSTMETHOD1(webrtc::RtpCapabilities,
+PROXY_CONSTMETHOD1(RtpCapabilities,
                    GetRtpReceiverCapabilities,
                    cricket::MediaType)
 PROXY_METHOD1(rtc::scoped_refptr<MediaStreamInterface>,
diff --git a/pc/peer_connection_factory_unittest.cc b/pc/peer_connection_factory_unittest.cc
index 91772ec..989b70f 100644
--- a/pc/peer_connection_factory_unittest.cc
+++ b/pc/peer_connection_factory_unittest.cc
@@ -106,8 +106,7 @@
       PeerConnectionInterface::IceConnectionState new_state) override {}
   void OnIceGatheringChange(
       PeerConnectionInterface::IceGatheringState new_state) override {}
-  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
-  }
+  void OnIceCandidate(const IceCandidateInterface* candidate) override {}
 };
 
 class MockNetworkManager : public rtc::NetworkManager {
@@ -133,17 +132,15 @@
  private:
   void SetUp() {
 #ifdef WEBRTC_ANDROID
-    webrtc::InitializeAndroidObjects();
+    InitializeAndroidObjects();
 #endif
     // Use fake audio device module since we're only testing the interface
     // level, and using a real one could make tests flaky e.g. when run in
     // parallel.
-    factory_ = webrtc::CreatePeerConnectionFactory(
+    factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        rtc::scoped_refptr<webrtc::AudioDeviceModule>(
-            FakeAudioCaptureModule::Create()),
-        webrtc::CreateBuiltinAudioEncoderFactory(),
-        webrtc::CreateBuiltinAudioDecoderFactory(),
+        rtc::scoped_refptr<AudioDeviceModule>(FakeAudioCaptureModule::Create()),
+        CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
         std::make_unique<VideoEncoderFactoryTemplate<
             LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
             OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
@@ -182,64 +179,64 @@
     }
   }
 
-  void VerifyAudioCodecCapability(const webrtc::RtpCodecCapability& codec) {
+  void VerifyAudioCodecCapability(const RtpCodecCapability& codec) {
     EXPECT_EQ(codec.kind, cricket::MEDIA_TYPE_AUDIO);
     EXPECT_FALSE(codec.name.empty());
     EXPECT_GT(codec.clock_rate, 0);
     EXPECT_GT(codec.num_channels, 0);
   }
 
-  void VerifyVideoCodecCapability(const webrtc::RtpCodecCapability& codec,
+  void VerifyVideoCodecCapability(const RtpCodecCapability& codec,
                                   bool sender) {
     EXPECT_EQ(codec.kind, cricket::MEDIA_TYPE_VIDEO);
     EXPECT_FALSE(codec.name.empty());
     EXPECT_GT(codec.clock_rate, 0);
     if (sender) {
       if (codec.name == "VP8" || codec.name == "H264") {
-        EXPECT_THAT(codec.scalability_modes,
-                    UnorderedElementsAre(webrtc::ScalabilityMode::kL1T1,
-                                         webrtc::ScalabilityMode::kL1T2,
-                                         webrtc::ScalabilityMode::kL1T3))
+        EXPECT_THAT(
+            codec.scalability_modes,
+            UnorderedElementsAre(ScalabilityMode::kL1T1, ScalabilityMode::kL1T2,
+                                 ScalabilityMode::kL1T3))
             << "Codec: " << codec.name;
       } else if (codec.name == "VP9" || codec.name == "AV1") {
         EXPECT_THAT(
             codec.scalability_modes,
             UnorderedElementsAre(
                 // clang-format off
-                webrtc::ScalabilityMode::kL1T1,
-                webrtc::ScalabilityMode::kL1T2,
-                webrtc::ScalabilityMode::kL1T3,
-                webrtc::ScalabilityMode::kL2T1,
-                webrtc::ScalabilityMode::kL2T1h,
-                webrtc::ScalabilityMode::kL2T1_KEY,
-                webrtc::ScalabilityMode::kL2T2,
-                webrtc::ScalabilityMode::kL2T2h,
-                webrtc::ScalabilityMode::kL2T2_KEY,
-                webrtc::ScalabilityMode::kL2T2_KEY_SHIFT,
-                webrtc::ScalabilityMode::kL2T3,
-                webrtc::ScalabilityMode::kL2T3h,
-                webrtc::ScalabilityMode::kL2T3_KEY,
-                webrtc::ScalabilityMode::kL3T1,
-                webrtc::ScalabilityMode::kL3T1h,
-                webrtc::ScalabilityMode::kL3T1_KEY,
-                webrtc::ScalabilityMode::kL3T2,
-                webrtc::ScalabilityMode::kL3T2h,
-                webrtc::ScalabilityMode::kL3T2_KEY,
-                webrtc::ScalabilityMode::kL3T3,
-                webrtc::ScalabilityMode::kL3T3h,
-                webrtc::ScalabilityMode::kL3T3_KEY,
-                webrtc::ScalabilityMode::kS2T1,
-                webrtc::ScalabilityMode::kS2T1h,
-                webrtc::ScalabilityMode::kS2T2,
-                webrtc::ScalabilityMode::kS2T2h,
-                webrtc::ScalabilityMode::kS2T3,
-                webrtc::ScalabilityMode::kS2T3h,
-                webrtc::ScalabilityMode::kS3T1,
-                webrtc::ScalabilityMode::kS3T1h,
-                webrtc::ScalabilityMode::kS3T2,
-                webrtc::ScalabilityMode::kS3T2h,
-                webrtc::ScalabilityMode::kS3T3,
-                webrtc::ScalabilityMode::kS3T3h)
+                ScalabilityMode::kL1T1,
+                ScalabilityMode::kL1T2,
+                ScalabilityMode::kL1T3,
+                ScalabilityMode::kL2T1,
+                ScalabilityMode::kL2T1h,
+                ScalabilityMode::kL2T1_KEY,
+                ScalabilityMode::kL2T2,
+                ScalabilityMode::kL2T2h,
+                ScalabilityMode::kL2T2_KEY,
+                ScalabilityMode::kL2T2_KEY_SHIFT,
+                ScalabilityMode::kL2T3,
+                ScalabilityMode::kL2T3h,
+                ScalabilityMode::kL2T3_KEY,
+                ScalabilityMode::kL3T1,
+                ScalabilityMode::kL3T1h,
+                ScalabilityMode::kL3T1_KEY,
+                ScalabilityMode::kL3T2,
+                ScalabilityMode::kL3T2h,
+                ScalabilityMode::kL3T2_KEY,
+                ScalabilityMode::kL3T3,
+                ScalabilityMode::kL3T3h,
+                ScalabilityMode::kL3T3_KEY,
+                ScalabilityMode::kS2T1,
+                ScalabilityMode::kS2T1h,
+                ScalabilityMode::kS2T2,
+                ScalabilityMode::kS2T2h,
+                ScalabilityMode::kS2T3,
+                ScalabilityMode::kS2T3h,
+                ScalabilityMode::kS3T1,
+                ScalabilityMode::kS3T1h,
+                ScalabilityMode::kS3T2,
+                ScalabilityMode::kS3T2h,
+                ScalabilityMode::kS3T3,
+                ScalabilityMode::kS3T3h)
             // clang-format on
             )
             << "Codec: " << codec.name;
@@ -251,7 +248,7 @@
     }
   }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   std::unique_ptr<rtc::SocketServer> socket_server_;
   rtc::AutoSocketServerThread main_thread_;
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
@@ -267,7 +264,7 @@
 // to reconstruct factory with our own ConnectionContext.
 rtc::scoped_refptr<PeerConnectionFactoryInterface>
 CreatePeerConnectionFactoryWithRtxDisabled() {
-  webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
+  PeerConnectionFactoryDependencies pcf_dependencies;
   pcf_dependencies.signaling_thread = rtc::Thread::Current();
   pcf_dependencies.worker_thread = rtc::Thread::Current();
   pcf_dependencies.network_thread = rtc::Thread::Current();
@@ -287,7 +284,7 @@
           OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
   EnableMedia(pcf_dependencies);
 
-  rtc::scoped_refptr<webrtc::ConnectionContext> context =
+  rtc::scoped_refptr<ConnectionContext> context =
       ConnectionContext::Create(&pcf_dependencies);
   context->set_use_rtx(false);
   return rtc::make_ref_counted<PeerConnectionFactory>(context,
@@ -302,26 +299,26 @@
 // See https://bugs.chromium.org/p/webrtc/issues/detail?id=7806 for details.
 TEST(PeerConnectionFactoryTestInternal, DISABLED_CreatePCUsingInternalModules) {
 #ifdef WEBRTC_ANDROID
-  webrtc::InitializeAndroidObjects();
+  InitializeAndroidObjects();
 #endif
 
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
-      webrtc::CreatePeerConnectionFactory(
+      CreatePeerConnectionFactory(
           nullptr /* network_thread */, nullptr /* worker_thread */,
           nullptr /* signaling_thread */, nullptr /* default_adm */,
-          webrtc::CreateBuiltinAudioEncoderFactory(),
-          webrtc::CreateBuiltinAudioDecoderFactory(),
+          CreateBuiltinAudioEncoderFactory(),
+          CreateBuiltinAudioDecoderFactory(),
           nullptr /* video_encoder_factory */,
           nullptr /* video_decoder_factory */, nullptr /* audio_mixer */,
           nullptr /* audio_processing */));
 
   NullPeerConnectionObserver observer;
-  webrtc::PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::RTCConfiguration config;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
 
   std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
       new FakeRTCCertificateGenerator());
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer);
+  PeerConnectionDependencies pc_dependencies(&observer);
   pc_dependencies.cert_generator = std::move(cert_generator);
   auto result =
       factory->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
@@ -330,7 +327,7 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpSenderAudioCapabilities) {
-  webrtc::RtpCapabilities audio_capabilities =
+  RtpCapabilities audio_capabilities =
       factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO);
   EXPECT_FALSE(audio_capabilities.codecs.empty());
   for (const auto& codec : audio_capabilities.codecs) {
@@ -343,7 +340,7 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpSenderVideoCapabilities) {
-  webrtc::RtpCapabilities video_capabilities =
+  RtpCapabilities video_capabilities =
       factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
   EXPECT_FALSE(video_capabilities.codecs.empty());
   for (const auto& codec : video_capabilities.codecs) {
@@ -356,7 +353,7 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpSenderRtxEnabledCapabilities) {
-  webrtc::RtpCapabilities video_capabilities =
+  RtpCapabilities video_capabilities =
       factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
   const auto it = std::find_if(
       video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@@ -366,7 +363,7 @@
 
 TEST(PeerConnectionFactoryTestInternal, CheckRtpSenderRtxDisabledCapabilities) {
   auto factory = CreatePeerConnectionFactoryWithRtxDisabled();
-  webrtc::RtpCapabilities video_capabilities =
+  RtpCapabilities video_capabilities =
       factory->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO);
   const auto it = std::find_if(
       video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@@ -375,14 +372,14 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpSenderDataCapabilities) {
-  webrtc::RtpCapabilities data_capabilities =
+  RtpCapabilities data_capabilities =
       factory_->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_DATA);
   EXPECT_TRUE(data_capabilities.codecs.empty());
   EXPECT_TRUE(data_capabilities.header_extensions.empty());
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverAudioCapabilities) {
-  webrtc::RtpCapabilities audio_capabilities =
+  RtpCapabilities audio_capabilities =
       factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_AUDIO);
   EXPECT_FALSE(audio_capabilities.codecs.empty());
   for (const auto& codec : audio_capabilities.codecs) {
@@ -395,7 +392,7 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverVideoCapabilities) {
-  webrtc::RtpCapabilities video_capabilities =
+  RtpCapabilities video_capabilities =
       factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
   EXPECT_FALSE(video_capabilities.codecs.empty());
   for (const auto& codec : video_capabilities.codecs) {
@@ -408,7 +405,7 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverRtxEnabledCapabilities) {
-  webrtc::RtpCapabilities video_capabilities =
+  RtpCapabilities video_capabilities =
       factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
   const auto it = std::find_if(
       video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@@ -419,7 +416,7 @@
 TEST(PeerConnectionFactoryTestInternal,
      CheckRtpReceiverRtxDisabledCapabilities) {
   auto factory = CreatePeerConnectionFactoryWithRtxDisabled();
-  webrtc::RtpCapabilities video_capabilities =
+  RtpCapabilities video_capabilities =
       factory->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_VIDEO);
   const auto it = std::find_if(
       video_capabilities.codecs.begin(), video_capabilities.codecs.end(),
@@ -428,7 +425,7 @@
 }
 
 TEST_F(PeerConnectionFactoryTest, CheckRtpReceiverDataCapabilities) {
-  webrtc::RtpCapabilities data_capabilities =
+  RtpCapabilities data_capabilities =
       factory_->GetRtpReceiverCapabilities(cricket::MEDIA_TYPE_DATA);
   EXPECT_TRUE(data_capabilities.codecs.empty());
   EXPECT_TRUE(data_capabilities.header_extensions.empty());
@@ -438,8 +435,8 @@
 // configuration. Also verifies the URL's parsed correctly as expected.
 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServers) {
   PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.uri = kStunIceServer;
   config.servers.push_back(ice_server);
   ice_server.uri = kTurnIceServer;
@@ -450,7 +447,7 @@
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
+  PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.cert_generator =
       std::make_unique<FakeRTCCertificateGenerator>();
   pc_dependencies.allocator = std::move(port_allocator_);
@@ -475,15 +472,15 @@
 // configuration. Also verifies the list of URL's parsed correctly as expected.
 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIceServersUrls) {
   PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back(kStunIceServer);
   ice_server.urls.push_back(kTurnIceServer);
   ice_server.urls.push_back(kTurnIceServerWithTransport);
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
+  PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.cert_generator =
       std::make_unique<FakeRTCCertificateGenerator>();
   pc_dependencies.allocator = std::move(port_allocator_);
@@ -506,15 +503,15 @@
 
 TEST_F(PeerConnectionFactoryTest, CreatePCUsingNoUsernameInUri) {
   PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.uri = kStunIceServer;
   config.servers.push_back(ice_server);
   ice_server.uri = kTurnIceServerWithNoUsernameInUri;
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
+  PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.cert_generator =
       std::make_unique<FakeRTCCertificateGenerator>();
   pc_dependencies.allocator = std::move(port_allocator_);
@@ -532,13 +529,13 @@
 // has transport parameter in it.
 TEST_F(PeerConnectionFactoryTest, CreatePCUsingTurnUrlWithTransportParam) {
   PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.uri = kTurnIceServerWithTransport;
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
+  PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.cert_generator =
       std::make_unique<FakeRTCCertificateGenerator>();
   pc_dependencies.allocator = std::move(port_allocator_);
@@ -554,8 +551,8 @@
 
 TEST_F(PeerConnectionFactoryTest, CreatePCUsingSecureTurnUrl) {
   PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.uri = kSecureTurnIceServer;
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
@@ -568,7 +565,7 @@
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
+  PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.cert_generator =
       std::make_unique<FakeRTCCertificateGenerator>();
   pc_dependencies.allocator = std::move(port_allocator_);
@@ -593,8 +590,8 @@
 
 TEST_F(PeerConnectionFactoryTest, CreatePCUsingIPLiteralAddress) {
   PeerConnectionInterface::RTCConfiguration config;
-  config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  config.sdp_semantics = SdpSemantics::kUnifiedPlan;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.uri = kStunIceServerWithIPv4Address;
   config.servers.push_back(ice_server);
   ice_server.uri = kStunIceServerWithIPv4AddressWithoutPort;
@@ -607,7 +604,7 @@
   ice_server.username = kTurnUsername;
   ice_server.password = kTurnPassword;
   config.servers.push_back(ice_server);
-  webrtc::PeerConnectionDependencies pc_dependencies(&observer_);
+  PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.cert_generator =
       std::make_unique<FakeRTCCertificateGenerator>();
   pc_dependencies.allocator = std::move(port_allocator_);
@@ -635,8 +632,8 @@
 // This test verifies the captured stream is rendered locally using a
 // local video track.
 TEST_F(PeerConnectionFactoryTest, LocalRendering) {
-  rtc::scoped_refptr<webrtc::FakeVideoTrackSource> source =
-      webrtc::FakeVideoTrackSource::Create(/*is_screencast=*/false);
+  rtc::scoped_refptr<FakeVideoTrackSource> source =
+      FakeVideoTrackSource::Create(/*is_screencast=*/false);
 
   cricket::FakeFrameSource frame_source(1280, 720,
                                         rtc::kNumMicrosecsPerSec / 30);
@@ -664,7 +661,7 @@
 }
 
 TEST(PeerConnectionFactoryDependenciesTest, UsesNetworkManager) {
-  constexpr webrtc::TimeDelta kWaitTimeout = webrtc::TimeDelta::Seconds(10);
+  constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
   auto mock_network_manager = std::make_unique<NiceMock<MockNetworkManager>>();
 
   rtc::Event called;
@@ -672,24 +669,24 @@
       .Times(AtLeast(1))
       .WillRepeatedly(InvokeWithoutArgs([&] { called.Set(); }));
 
-  webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
+  PeerConnectionFactoryDependencies pcf_dependencies;
   pcf_dependencies.network_manager = std::move(mock_network_manager);
 
-  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf =
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> pcf =
       CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
 
   PeerConnectionInterface::RTCConfiguration config;
   config.ice_candidate_pool_size = 2;
   NullPeerConnectionObserver observer;
   auto pc = pcf->CreatePeerConnectionOrError(
-      config, webrtc::PeerConnectionDependencies(&observer));
+      config, PeerConnectionDependencies(&observer));
   ASSERT_TRUE(pc.ok());
 
   called.Wait(kWaitTimeout);
 }
 
 TEST(PeerConnectionFactoryDependenciesTest, UsesPacketSocketFactory) {
-  constexpr webrtc::TimeDelta kWaitTimeout = webrtc::TimeDelta::Seconds(10);
+  constexpr TimeDelta kWaitTimeout = TimeDelta::Seconds(10);
   auto mock_socket_factory =
       std::make_unique<NiceMock<rtc::MockPacketSocketFactory>>();
 
@@ -701,10 +698,10 @@
       }))
       .WillRepeatedly(Return(nullptr));
 
-  webrtc::PeerConnectionFactoryDependencies pcf_dependencies;
+  PeerConnectionFactoryDependencies pcf_dependencies;
   pcf_dependencies.packet_socket_factory = std::move(mock_socket_factory);
 
-  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf =
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> pcf =
       CreateModularPeerConnectionFactory(std::move(pcf_dependencies));
 
   // By default, localhost addresses are ignored, which makes tests fail if test
@@ -717,7 +714,7 @@
   config.ice_candidate_pool_size = 2;
   NullPeerConnectionObserver observer;
   auto pc = pcf->CreatePeerConnectionOrError(
-      config, webrtc::PeerConnectionDependencies(&observer));
+      config, PeerConnectionDependencies(&observer));
   ASSERT_TRUE(pc.ok());
 
   called.Wait(kWaitTimeout);
diff --git a/pc/peer_connection_field_trial_tests.cc b/pc/peer_connection_field_trial_tests.cc
index c009475..4cbe249 100644
--- a/pc/peer_connection_field_trial_tests.cc
+++ b/pc/peer_connection_field_trial_tests.cc
@@ -68,7 +68,7 @@
 #ifdef WEBRTC_ANDROID
     InitializeAndroidObjects();
 #endif
-    webrtc::PeerConnectionInterface::IceServer ice_server;
+    PeerConnectionInterface::IceServer ice_server;
     ice_server.uri = "stun:stun.l.google.com:19302";
     config_.servers.push_back(ice_server);
     config_.sdp_semantics = SdpSemantics::kUnifiedPlan;
@@ -108,7 +108,7 @@
   std::unique_ptr<rtc::SocketServer> socket_server_;
   rtc::AutoSocketServerThread main_thread_;
   rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
-  webrtc::PeerConnectionInterface::RTCConfiguration config_;
+  PeerConnectionInterface::RTCConfiguration config_;
 };
 
 // Tests for the dependency descriptor field trial. The dependency descriptor
@@ -133,7 +133,7 @@
       media_description1->rtp_header_extensions();
 
   bool found = absl::c_find_if(rtp_header_extensions1,
-                               [](const webrtc::RtpExtension& rtp_extension) {
+                               [](const RtpExtension& rtp_extension) {
                                  return rtp_extension.uri ==
                                         RtpExtension::kDependencyDescriptorUri;
                                }) != rtp_header_extensions1.end();
@@ -163,14 +163,14 @@
       media_description1->rtp_header_extensions();
 
   bool found1 = absl::c_find_if(rtp_header_extensions1,
-                                [](const webrtc::RtpExtension& rtp_extension) {
+                                [](const RtpExtension& rtp_extension) {
                                   return rtp_extension.uri ==
                                          RtpExtension::kDependencyDescriptorUri;
                                 }) != rtp_header_extensions1.end();
   EXPECT_FALSE(found1);
 
   std::set<int> existing_ids;
-  for (const webrtc::RtpExtension& rtp_extension : rtp_header_extensions1) {
+  for (const RtpExtension& rtp_extension : rtp_header_extensions1) {
     existing_ids.insert(rtp_extension.id);
   }
 
@@ -207,7 +207,7 @@
       media_description2->rtp_header_extensions();
 
   bool found2 = absl::c_find_if(rtp_header_extensions2,
-                                [](const webrtc::RtpExtension& rtp_extension) {
+                                [](const RtpExtension& rtp_extension) {
                                   return rtp_extension.uri ==
                                          RtpExtension::kDependencyDescriptorUri;
                                 }) != rtp_header_extensions2.end();
diff --git a/pc/peer_connection_header_extension_unittest.cc b/pc/peer_connection_header_extension_unittest.cc
index dd5d4b0..277979b 100644
--- a/pc/peer_connection_header_extension_unittest.cc
+++ b/pc/peer_connection_header_extension_unittest.cc
@@ -114,7 +114,7 @@
         pc_factory, result.MoveValue(), std::move(observer));
   }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   std::unique_ptr<rtc::SocketServer> socket_server_;
   rtc::AutoSocketServerThread main_thread_;
   std::vector<RtpHeaderExtensionCapability> extensions_;
diff --git a/pc/peer_connection_histogram_unittest.cc b/pc/peer_connection_histogram_unittest.cc
index cadb083..973744c 100644
--- a/pc/peer_connection_histogram_unittest.cc
+++ b/pc/peer_connection_histogram_unittest.cc
@@ -94,7 +94,7 @@
 
 class ObserverForUsageHistogramTest : public MockPeerConnectionObserver {
  public:
-  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override;
+  void OnIceCandidate(const IceCandidateInterface* candidate) override;
 
   void OnInterestingUsage(int usage_pattern) override {
     interesting_usage_detected_ = usage_pattern;
@@ -157,12 +157,11 @@
     return static_cast<ObserverForUsageHistogramTest*>(observer())
         ->HaveDataChannel();
   }
-  void BufferIceCandidate(const webrtc::IceCandidateInterface* candidate) {
+  void BufferIceCandidate(const IceCandidateInterface* candidate) {
     std::string sdp;
     EXPECT_TRUE(candidate->ToString(&sdp));
-    std::unique_ptr<webrtc::IceCandidateInterface> candidate_copy(
-        CreateIceCandidate(candidate->sdp_mid(), candidate->sdp_mline_index(),
-                           sdp, nullptr));
+    std::unique_ptr<IceCandidateInterface> candidate_copy(CreateIceCandidate(
+        candidate->sdp_mid(), candidate->sdp_mline_index(), sdp, nullptr));
     buffered_candidates_.push_back(std::move(candidate_copy));
   }
 
@@ -213,19 +212,18 @@
     return true;
   }
 
-  webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() {
+  PeerConnectionInterface::IceGatheringState ice_gathering_state() {
     return pc()->ice_gathering_state();
   }
 
  private:
   // Candidates that have been sent but not yet configured
-  std::vector<std::unique_ptr<webrtc::IceCandidateInterface>>
-      buffered_candidates_;
+  std::vector<std::unique_ptr<IceCandidateInterface>> buffered_candidates_;
 };
 
 // Buffers candidates until we add them via AddBufferedIceCandidates.
 void ObserverForUsageHistogramTest::OnIceCandidate(
-    const webrtc::IceCandidateInterface* candidate) {
+    const IceCandidateInterface* candidate) {
   // If target is not set, ignore. This happens in one-ended unit tests.
   if (candidate_target_) {
     this->candidate_target_->BufferIceCandidate(candidate);
@@ -242,12 +240,12 @@
       : vss_(new rtc::VirtualSocketServer()),
         socket_factory_(new rtc::BasicPacketSocketFactory(vss_.get())),
         main_(vss_.get()) {
-    webrtc::metrics::Reset();
+    metrics::Reset();
   }
 
   WrapperPtr CreatePeerConnection() {
     RTCConfiguration config;
-    config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
+    config.sdp_semantics = SdpSemantics::kUnifiedPlan;
     return CreatePeerConnection(
         config, PeerConnectionFactoryInterface::Options(), nullptr);
   }
@@ -259,13 +257,13 @@
 
   WrapperPtr CreatePeerConnectionWithMdns(const RTCConfiguration& config) {
     auto resolver_factory =
-        std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>();
+        std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
 
-    webrtc::PeerConnectionDependencies deps(nullptr /* observer_in */);
+    PeerConnectionDependencies deps(nullptr /* observer_in */);
 
     auto fake_network = NewFakeNetwork();
     fake_network->set_mdns_responder(
-        std::make_unique<webrtc::FakeMdnsResponder>(rtc::Thread::Current()));
+        std::make_unique<FakeMdnsResponder>(rtc::Thread::Current()));
     fake_network->AddInterface(NextLocalAddress());
 
     std::unique_ptr<cricket::BasicPortAllocator> port_allocator(
@@ -280,7 +278,7 @@
 
   WrapperPtr CreatePeerConnectionWithImmediateReport() {
     RTCConfiguration configuration;
-    configuration.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
+    configuration.sdp_semantics = SdpSemantics::kUnifiedPlan;
     configuration.report_usage_pattern_delay_ms = 0;
     return CreatePeerConnection(
         configuration, PeerConnectionFactoryInterface::Options(), nullptr);
@@ -361,7 +359,7 @@
     // This works correctly only if there is only one sample value
     // that has been counted.
     // Returns -1 for "not found".
-    return webrtc::metrics::MinSample(kUsagePatternMetric);
+    return metrics::MinSample(kUsagePatternMetric);
   }
 
   // The PeerConnection's port allocator is tied to the PeerConnection's
@@ -390,10 +388,10 @@
   auto pc = CreatePeerConnectionWithImmediateReport();
 
   int expected_fingerprint = MakeUsageFingerprint({});
-  EXPECT_METRIC_EQ_WAIT(1, webrtc::metrics::NumSamples(kUsagePatternMetric),
+  EXPECT_METRIC_EQ_WAIT(1, metrics::NumSamples(kUsagePatternMetric),
                         kDefaultTimeout);
   EXPECT_METRIC_EQ(
-      1, webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
 }
 
 #ifndef WEBRTC_ANDROID
@@ -418,11 +416,10 @@
        UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
   // In this case, we may or may not have PRIVATE_CANDIDATE_COLLECTED,
   // depending on the machine configuration.
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
   EXPECT_METRIC_TRUE(
-      webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) ==
-          2 ||
-      webrtc::metrics::NumEvents(
+      metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) == 2 ||
+      metrics::NumEvents(
           kUsagePatternMetric,
           expected_fingerprint |
               static_cast<int>(UsageEvent::PRIVATE_CANDIDATE_COLLECTED)) == 2);
@@ -463,11 +460,11 @@
        UsageEvent::CANDIDATE_COLLECTED, UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED,
        UsageEvent::REMOTE_MDNS_CANDIDATE_ADDED, UsageEvent::ICE_STATE_CONNECTED,
        UsageEvent::REMOTE_CANDIDATE_ADDED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_caller));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_callee));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
 }
 
 // Test getting the usage fingerprint when the callee collects an mDNS
@@ -504,11 +501,11 @@
        UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED, UsageEvent::ICE_STATE_CONNECTED,
        UsageEvent::REMOTE_CANDIDATE_ADDED,
        UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_caller));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_callee));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
 }
 
 #ifdef WEBRTC_HAVE_SCTP
@@ -526,11 +523,10 @@
        UsageEvent::CANDIDATE_COLLECTED, UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED,
        UsageEvent::ICE_STATE_CONNECTED, UsageEvent::REMOTE_CANDIDATE_ADDED,
        UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
   EXPECT_METRIC_TRUE(
-      webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) ==
-          2 ||
-      webrtc::metrics::NumEvents(
+      metrics::NumEvents(kUsagePatternMetric, expected_fingerprint) == 2 ||
+      metrics::NumEvents(
           kUsagePatternMetric,
           expected_fingerprint |
               static_cast<int>(UsageEvent::PRIVATE_CANDIDATE_COLLECTED)) == 2);
@@ -554,9 +550,9 @@
   int expected_fingerprint = MakeUsageFingerprint(
       {UsageEvent::STUN_SERVER_ADDED, UsageEvent::TURN_SERVER_ADDED,
        UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
   EXPECT_METRIC_EQ(
-      1, webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
 }
 
 TEST_F(PeerConnectionUsageHistogramTest, FingerprintStunTurnInReconfiguration) {
@@ -576,9 +572,9 @@
   int expected_fingerprint = MakeUsageFingerprint(
       {UsageEvent::STUN_SERVER_ADDED, UsageEvent::TURN_SERVER_ADDED,
        UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
   EXPECT_METRIC_EQ(
-      1, webrtc::metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint));
 }
 
 TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithPrivateIPCaller) {
@@ -604,11 +600,11 @@
        UsageEvent::REMOTE_PRIVATE_CANDIDATE_ADDED,
        UsageEvent::ICE_STATE_CONNECTED, UsageEvent::REMOTE_CANDIDATE_ADDED,
        UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_caller));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_callee));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
 }
 
 TEST_F(PeerConnectionUsageHistogramTest, FingerprintWithPrivateIpv6Callee) {
@@ -636,11 +632,11 @@
        UsageEvent::ADD_ICE_CANDIDATE_SUCCEEDED,
        UsageEvent::REMOTE_CANDIDATE_ADDED, UsageEvent::ICE_STATE_CONNECTED,
        UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_caller));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_callee));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
 }
 
 #ifndef WEBRTC_ANDROID
@@ -664,7 +660,7 @@
   ASSERT_TRUE(caller->SetLocalDescription(caller->CreateOffer()));
   // Wait until the gathering completes so that the session description would
   // have contained ICE candidates.
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
                  caller->ice_gathering_state(), kDefaultTimeout);
   EXPECT_TRUE(caller->observer()->candidate_gathered());
   // Get the current offer that contains candidates and pass it to the callee.
@@ -713,11 +709,11 @@
        UsageEvent::REMOTE_PRIVATE_CANDIDATE_ADDED,
        UsageEvent::REMOTE_IPV6_CANDIDATE_ADDED, UsageEvent::ICE_STATE_CONNECTED,
        UsageEvent::DIRECT_CONNECTION_SELECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(2, webrtc::metrics::NumSamples(kUsagePatternMetric));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_caller));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(kUsagePatternMetric,
-                                                 expected_fingerprint_callee));
+  EXPECT_METRIC_EQ(2, metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_caller));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents(kUsagePatternMetric, expected_fingerprint_callee));
 }
 
 TEST_F(PeerConnectionUsageHistogramTest, NotableUsageNoted) {
@@ -728,7 +724,7 @@
   int expected_fingerprint = MakeUsageFingerprint(
       {UsageEvent::DATA_ADDED, UsageEvent::SET_LOCAL_DESCRIPTION_SUCCEEDED,
        UsageEvent::CANDIDATE_COLLECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
   EXPECT_METRIC_TRUE(
       expected_fingerprint == ObservedFingerprint() ||
       (expected_fingerprint |
@@ -745,9 +741,9 @@
   int expected_fingerprint = MakeUsageFingerprint(
       {UsageEvent::DATA_ADDED, UsageEvent::SET_LOCAL_DESCRIPTION_SUCCEEDED,
        UsageEvent::CANDIDATE_COLLECTED});
-  EXPECT_METRIC_EQ(0, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(0, metrics::NumSamples(kUsagePatternMetric));
   caller->GetInternalPeerConnection()->RequestUsagePatternReportForTesting();
-  EXPECT_METRIC_EQ_WAIT(1, webrtc::metrics::NumSamples(kUsagePatternMetric),
+  EXPECT_METRIC_EQ_WAIT(1, metrics::NumSamples(kUsagePatternMetric),
                         kDefaultTimeout);
   EXPECT_METRIC_TRUE(
       expected_fingerprint == ObservedFingerprint() ||
@@ -766,12 +762,12 @@
   int expected_fingerprint = MakeUsageFingerprint(
       {UsageEvent::DATA_ADDED, UsageEvent::SET_LOCAL_DESCRIPTION_SUCCEEDED,
        UsageEvent::CANDIDATE_COLLECTED, UsageEvent::CLOSE_CALLED});
-  EXPECT_METRIC_EQ(0, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(0, metrics::NumSamples(kUsagePatternMetric));
   caller->pc()->Close();
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumSamples(kUsagePatternMetric));
+  EXPECT_METRIC_EQ(1, metrics::NumSamples(kUsagePatternMetric));
   caller->GetInternalPeerConnection()->RequestUsagePatternReportForTesting();
   caller->observer()->ClearInterestingUsageDetector();
-  EXPECT_METRIC_EQ_WAIT(2, webrtc::metrics::NumSamples(kUsagePatternMetric),
+  EXPECT_METRIC_EQ_WAIT(2, metrics::NumSamples(kUsagePatternMetric),
                         kDefaultTimeout);
   EXPECT_METRIC_TRUE(
       expected_fingerprint == ObservedFingerprint() ||
diff --git a/pc/peer_connection_ice_unittest.cc b/pc/peer_connection_ice_unittest.cc
index 532583f..492e108 100644
--- a/pc/peer_connection_ice_unittest.cc
+++ b/pc/peer_connection_ice_unittest.cc
@@ -342,7 +342,7 @@
       public ::testing::WithParamInterface<SdpSemantics> {
  protected:
   PeerConnectionIceTest() : PeerConnectionIceBaseTest(GetParam()) {
-    webrtc::metrics::Reset();
+    metrics::Reset();
   }
 };
 
@@ -514,7 +514,7 @@
 
   EXPECT_FALSE(caller->pc()->AddIceCandidate(jsep_candidate.get()));
   EXPECT_METRIC_THAT(
-      webrtc::metrics::Samples("WebRTC.PeerConnection.AddIceCandidate"),
+      metrics::Samples("WebRTC.PeerConnection.AddIceCandidate"),
       ElementsAre(Pair(kAddIceCandidateFailNoRemoteDescription, 2)));
 }
 
@@ -1457,7 +1457,7 @@
     pc_ = result.MoveValue();
   }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   std::unique_ptr<rtc::SocketServer> socket_server_;
   rtc::AutoSocketServerThread main_thread_;
   rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index d76e5e27..1ea16a6 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -124,7 +124,7 @@
     // Some things use a time of "0" as a special value, so we need to start out
     // the fake clock at a nonzero time.
     // TODO(deadbeef): Fix this.
-    AdvanceTime(webrtc::TimeDelta::Seconds(1));
+    AdvanceTime(TimeDelta::Seconds(1));
   }
 
   // Explicit handle.
@@ -324,7 +324,7 @@
   ConnectFakeSignaling();
 
   // Add video tracks with 16:9 aspect ratio, size 1280 x 720.
-  webrtc::FakePeriodicVideoSource::Config config;
+  FakePeriodicVideoSource::Config config;
   config.width = 1280;
   config.height = 720;
   config.timestamp_offset_ms = rtc::TimeMillis();
@@ -366,7 +366,7 @@
       CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
   ConnectFakeSignaling();
   // Add one-directional video, from caller to callee.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+  rtc::scoped_refptr<VideoTrackInterface> caller_track =
       caller()->CreateLocalVideoTrack();
   caller()->AddTrack(caller_track);
   PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -391,7 +391,7 @@
       CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/false));
   ConnectFakeSignaling();
   // Add one-directional video, from callee to caller.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+  rtc::scoped_refptr<VideoTrackInterface> callee_track =
       callee()->CreateLocalVideoTrack();
   callee()->AddTrack(callee_track);
   PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -414,14 +414,14 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Add one-directional video, from caller to callee.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+  rtc::scoped_refptr<VideoTrackInterface> caller_track =
       caller()->CreateLocalVideoTrack();
   caller()->AddTrack(caller_track);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
   // Add receive video.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+  rtc::scoped_refptr<VideoTrackInterface> callee_track =
       callee()->CreateLocalVideoTrack();
   callee()->AddTrack(callee_track);
   caller()->CreateAndSetAndSignalOffer();
@@ -438,14 +438,14 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Add one-directional video, from callee to caller.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+  rtc::scoped_refptr<VideoTrackInterface> callee_track =
       callee()->CreateLocalVideoTrack();
   callee()->AddTrack(callee_track);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
   // Add send video.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+  rtc::scoped_refptr<VideoTrackInterface> caller_track =
       caller()->CreateLocalVideoTrack();
   caller()->AddTrack(caller_track);
   caller()->CreateAndSetAndSignalOffer();
@@ -462,15 +462,15 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Add send video, from caller to callee.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+  rtc::scoped_refptr<VideoTrackInterface> caller_track =
       caller()->CreateLocalVideoTrack();
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender =
+  rtc::scoped_refptr<RtpSenderInterface> caller_sender =
       caller()->AddTrack(caller_track);
   // Add receive video, from callee to caller.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+  rtc::scoped_refptr<VideoTrackInterface> callee_track =
       callee()->CreateLocalVideoTrack();
 
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender =
+  rtc::scoped_refptr<RtpSenderInterface> callee_sender =
       callee()->AddTrack(callee_track);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@@ -494,15 +494,15 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Add send video, from caller to callee.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+  rtc::scoped_refptr<VideoTrackInterface> caller_track =
       caller()->CreateLocalVideoTrack();
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> caller_sender =
+  rtc::scoped_refptr<RtpSenderInterface> caller_sender =
       caller()->AddTrack(caller_track);
   // Add receive video, from callee to caller.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+  rtc::scoped_refptr<VideoTrackInterface> callee_track =
       callee()->CreateLocalVideoTrack();
 
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> callee_sender =
+  rtc::scoped_refptr<RtpSenderInterface> callee_sender =
       callee()->AddTrack(callee_track);
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@@ -654,9 +654,9 @@
   ConnectFakeSignaling();
   // Add rotated video tracks.
   caller()->AddTrack(
-      caller()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_90));
+      caller()->CreateLocalVideoTrackWithRotation(kVideoRotation_90));
   callee()->AddTrack(
-      callee()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_270));
+      callee()->CreateLocalVideoTrackWithRotation(kVideoRotation_270));
 
   // Wait for video frames to be received by both sides.
   caller()->CreateAndSetAndSignalOffer();
@@ -673,8 +673,8 @@
   EXPECT_EQ(4.0 / 3, callee()->local_rendered_aspect_ratio());
   EXPECT_EQ(4.0 / 3, callee()->rendered_aspect_ratio());
   // Ensure that the CVO bits were surfaced to the renderer.
-  EXPECT_EQ(webrtc::kVideoRotation_270, caller()->rendered_rotation());
-  EXPECT_EQ(webrtc::kVideoRotation_90, callee()->rendered_rotation());
+  EXPECT_EQ(kVideoRotation_270, caller()->rendered_rotation());
+  EXPECT_EQ(kVideoRotation_90, callee()->rendered_rotation());
 }
 
 // Test that when the CVO extension isn't supported, video is rotated the
@@ -684,9 +684,9 @@
   ConnectFakeSignaling();
   // Add rotated video tracks.
   caller()->AddTrack(
-      caller()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_90));
+      caller()->CreateLocalVideoTrackWithRotation(kVideoRotation_90));
   callee()->AddTrack(
-      callee()->CreateLocalVideoTrackWithRotation(webrtc::kVideoRotation_270));
+      callee()->CreateLocalVideoTrackWithRotation(kVideoRotation_270));
 
   // Remove the CVO extension from the offered SDP.
   callee()->SetReceivedSdpMunger([](cricket::SessionDescription* desc) {
@@ -710,8 +710,8 @@
   EXPECT_EQ(3.0 / 4, callee()->local_rendered_aspect_ratio());
   EXPECT_EQ(3.0 / 4, callee()->rendered_aspect_ratio());
   // Expect that each endpoint is unaware of the rotation of the other endpoint.
-  EXPECT_EQ(webrtc::kVideoRotation_0, caller()->rendered_rotation());
-  EXPECT_EQ(webrtc::kVideoRotation_0, callee()->rendered_rotation());
+  EXPECT_EQ(kVideoRotation_0, caller()->rendered_rotation());
+  EXPECT_EQ(kVideoRotation_0, callee()->rendered_rotation());
 }
 
 // Test that if the answerer rejects the audio m= section, no audio is sent or
@@ -899,9 +899,9 @@
   ConnectFakeSignaling();
 
   // Add audio track, do normal offer/answer.
-  rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
+  rtc::scoped_refptr<AudioTrackInterface> track =
       caller()->CreateLocalAudioTrack();
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> sender =
+  rtc::scoped_refptr<RtpSenderInterface> sender =
       caller()->pc()->AddTrack(track, {"stream"}).MoveValue();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@@ -974,7 +974,7 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
   // Add one-directional video, from caller to callee.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
+  rtc::scoped_refptr<VideoTrackInterface> track =
       caller()->CreateLocalVideoTrack();
 
   RtpTransceiverInit video_transceiver_init;
@@ -988,7 +988,7 @@
   // Add receive direction.
   video_sender->SetDirectionWithError(RtpTransceiverDirection::kSendRecv);
 
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> callee_track =
+  rtc::scoped_refptr<VideoTrackInterface> callee_track =
       callee()->CreateLocalVideoTrack();
 
   callee()->AddTrack(callee_track);
@@ -1348,11 +1348,11 @@
       audio_sender_1->track()->id(), video_sender_1->track()->id(),
       audio_sender_2->track()->id(), video_sender_2->track()->id()};
 
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> caller_report =
+  rtc::scoped_refptr<const RTCStatsReport> caller_report =
       caller()->NewGetStats();
   ASSERT_TRUE(caller_report);
   auto outbound_stream_stats =
-      caller_report->GetStatsOfType<webrtc::RTCOutboundRtpStreamStats>();
+      caller_report->GetStatsOfType<RTCOutboundRtpStreamStats>();
   ASSERT_EQ(outbound_stream_stats.size(), 4u);
   std::vector<std::string> outbound_track_ids;
   for (const auto& stat : outbound_stream_stats) {
@@ -1373,11 +1373,11 @@
   }
   EXPECT_THAT(outbound_track_ids, UnorderedElementsAreArray(track_ids));
 
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> callee_report =
+  rtc::scoped_refptr<const RTCStatsReport> callee_report =
       callee()->NewGetStats();
   ASSERT_TRUE(callee_report);
   auto inbound_stream_stats =
-      callee_report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
+      callee_report->GetStatsOfType<RTCInboundRtpStreamStats>();
   ASSERT_EQ(4u, inbound_stream_stats.size());
   std::vector<std::string> inbound_track_ids;
   for (const auto& stat : inbound_stream_stats) {
@@ -1412,11 +1412,10 @@
 
   // We received a frame, so we should have nonzero "bytes received" stats for
   // the unsignaled stream, if stats are working for it.
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> report =
-      callee()->NewGetStats();
+  rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
   ASSERT_NE(nullptr, report);
   auto inbound_stream_stats =
-      report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
+      report->GetStatsOfType<RTCInboundRtpStreamStats>();
   ASSERT_EQ(1U, inbound_stream_stats.size());
   ASSERT_TRUE(inbound_stream_stats[0]->bytes_received.is_defined());
   ASSERT_GT(*inbound_stream_stats[0]->bytes_received, 0U);
@@ -1459,12 +1458,10 @@
   media_expectations.CalleeExpectsSomeVideo(1);
   ASSERT_TRUE(ExpectNewFrames(media_expectations));
 
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> report =
-      callee()->NewGetStats();
+  rtc::scoped_refptr<const RTCStatsReport> report = callee()->NewGetStats();
   ASSERT_NE(nullptr, report);
 
-  auto inbound_rtps =
-      report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
+  auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
   auto index = FindFirstMediaStatsIndexByKind("audio", inbound_rtps);
   ASSERT_GE(index, 0);
   EXPECT_TRUE(inbound_rtps[index]->audio_level.is_defined());
@@ -1655,18 +1652,18 @@
   callee()->AddAudioVideoTracks();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
                  caller()->ice_gathering_state(), kMaxWaitForFramesMs);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceGatheringComplete,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringComplete,
                  callee()->ice_gathering_state(), kMaxWaitForFramesMs);
   // After the best candidate pair is selected and all candidates are signaled,
   // the ICE connection state should reach "complete".
   // TODO(deadbeef): Currently, the ICE "controlled" agent (the
   // answerer/"callee" by default) only reaches "connected". When this is
   // fixed, this test should be updated.
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kDefaultTimeout);
 }
 
@@ -1679,9 +1676,9 @@
 TEST_P(PeerConnectionIntegrationTest,
        IceStatesReachCompletionWithRemoteHostname) {
   auto caller_resolver_factory =
-      std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>();
+      std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
   auto callee_resolver_factory =
-      std::make_unique<NiceMock<webrtc::MockAsyncDnsResolverFactory>>();
+      std::make_unique<NiceMock<MockAsyncDnsResolverFactory>>();
   auto callee_async_resolver =
       std::make_unique<NiceMock<MockAsyncDnsResolver>>();
   auto caller_async_resolver =
@@ -1695,12 +1692,12 @@
   // P2PTransportChannel.
   EXPECT_CALL(*caller_resolver_factory, Create())
       .WillOnce(Return(ByMove(std::move(caller_async_resolver))));
-  webrtc::PeerConnectionDependencies caller_deps(nullptr);
+  PeerConnectionDependencies caller_deps(nullptr);
   caller_deps.async_dns_resolver_factory = std::move(caller_resolver_factory);
 
   EXPECT_CALL(*callee_resolver_factory, Create())
       .WillOnce(Return(ByMove(std::move(callee_async_resolver))));
-  webrtc::PeerConnectionDependencies callee_deps(nullptr);
+  PeerConnectionDependencies callee_deps(nullptr);
   callee_deps.async_dns_resolver_factory = std::move(callee_resolver_factory);
 
   PeerConnectionInterface::RTCConfiguration config;
@@ -1719,9 +1716,9 @@
 
   // Enable hostname candidates with mDNS names.
   caller()->SetMdnsResponder(
-      std::make_unique<webrtc::FakeMdnsResponder>(network_thread()));
+      std::make_unique<FakeMdnsResponder>(network_thread()));
   callee()->SetMdnsResponder(
-      std::make_unique<webrtc::FakeMdnsResponder>(network_thread()));
+      std::make_unique<FakeMdnsResponder>(network_thread()));
 
   SetPortAllocatorFlags(kOnlyLocalPorts, kOnlyLocalPorts);
 
@@ -1730,18 +1727,18 @@
   callee()->AddAudioVideoTracks();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kDefaultTimeout);
 
   // Part of reporting the stats will occur on the network thread, so flush it
   // before checking NumEvents.
   SendTask(network_thread(), [] {});
 
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(
-                          "WebRTC.PeerConnection.CandidatePairType_UDP",
-                          webrtc::kIceCandidatePairHostNameHostName));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
+                            kIceCandidatePairHostNameHostName));
   DestroyPeerConnections();
 }
 
@@ -1862,9 +1859,9 @@
   caller()->CreateAndSetAndSignalOffer();
 
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kDefaultTimeout);
 
   // Part of reporting the stats will occur on the network thread, so flush it
@@ -1872,10 +1869,10 @@
   SendTask(network_thread(), [] {});
 
   // TODO(bugs.webrtc.org/9456): Fix it.
-  const int num_best_ipv4 = webrtc::metrics::NumEvents(
-      "WebRTC.PeerConnection.IPMetrics", webrtc::kBestConnections_IPv4);
-  const int num_best_ipv6 = webrtc::metrics::NumEvents(
-      "WebRTC.PeerConnection.IPMetrics", webrtc::kBestConnections_IPv6);
+  const int num_best_ipv4 = metrics::NumEvents(
+      "WebRTC.PeerConnection.IPMetrics", kBestConnections_IPv4);
+  const int num_best_ipv6 = metrics::NumEvents(
+      "WebRTC.PeerConnection.IPMetrics", kBestConnections_IPv6);
   if (TestIPv6()) {
     // When IPv6 is enabled, we should prefer an IPv6 connection over an IPv4
     // connection.
@@ -1886,12 +1883,12 @@
     EXPECT_METRIC_EQ(0, num_best_ipv6);
   }
 
-  EXPECT_METRIC_EQ(0, webrtc::metrics::NumEvents(
-                          "WebRTC.PeerConnection.CandidatePairType_UDP",
-                          webrtc::kIceCandidatePairHostHost));
-  EXPECT_METRIC_EQ(1, webrtc::metrics::NumEvents(
-                          "WebRTC.PeerConnection.CandidatePairType_UDP",
-                          webrtc::kIceCandidatePairHostPublicHostPublic));
+  EXPECT_METRIC_EQ(
+      0, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
+                            kIceCandidatePairHostHost));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents("WebRTC.PeerConnection.CandidatePairType_UDP",
+                            kIceCandidatePairHostPublicHostPublic));
 }
 
 constexpr uint32_t kFlagsIPv4NoStun = cricket::PORTALLOCATOR_DISABLE_TCP |
@@ -1931,17 +1928,17 @@
   callee()->AddAudioVideoTracks();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kMaxWaitForFramesMs);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kMaxWaitForFramesMs);
 
   // To verify that the ICE restart actually occurs, get
   // ufrag/password/candidates before and after restart.
   // Create an SDP string of the first audio candidate for both clients.
-  const webrtc::IceCandidateCollection* audio_candidates_caller =
+  const IceCandidateCollection* audio_candidates_caller =
       caller()->pc()->local_description()->candidates(0);
-  const webrtc::IceCandidateCollection* audio_candidates_callee =
+  const IceCandidateCollection* audio_candidates_callee =
       callee()->pc()->local_description()->candidates(0);
   ASSERT_GT(audio_candidates_caller->count(), 0u);
   ASSERT_GT(audio_candidates_callee->count(), 0u);
@@ -1964,9 +1961,9 @@
   caller()->SetOfferAnswerOptions(IceRestartOfferAnswerOptions());
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kMaxWaitForFramesMs);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kMaxWaitForFramesMs);
 
   // Grab the ufrags/candidates again.
@@ -2141,9 +2138,9 @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
   // Wait for ICE to complete, without any tracks being set.
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kMaxWaitForFramesMs);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kMaxWaitForFramesMs);
   // Now set the tracks, and expect frames to immediately start flowing.
   EXPECT_TRUE(
@@ -2182,9 +2179,9 @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kMaxWaitForActivationMs);
   // Wait for ICE to complete, without any tracks being set.
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionCompleted,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionCompleted,
                  caller()->ice_connection_state(), kMaxWaitForFramesMs);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kMaxWaitForFramesMs);
   // Now set the tracks, and expect frames to immediately start flowing.
   auto callee_audio_sender = callee()->pc()->GetSenders()[0];
@@ -2279,21 +2276,21 @@
   });
 
   PeerConnectionInterface::RTCConfiguration client_1_config;
-  webrtc::PeerConnectionInterface::IceServer ice_server_1;
+  PeerConnectionInterface::IceServer ice_server_1;
   ice_server_1.urls.push_back("turn:88.88.88.0:3478");
   ice_server_1.username = "test";
   ice_server_1.password = "test";
   client_1_config.servers.push_back(ice_server_1);
-  client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_1_config.type = PeerConnectionInterface::kRelay;
   client_1_config.presume_writable_when_fully_relayed = true;
 
   PeerConnectionInterface::RTCConfiguration client_2_config;
-  webrtc::PeerConnectionInterface::IceServer ice_server_2;
+  PeerConnectionInterface::IceServer ice_server_2;
   ice_server_2.urls.push_back("turn:99.99.99.0:3478");
   ice_server_2.username = "test";
   ice_server_2.password = "test";
   client_2_config.servers.push_back(ice_server_2);
-  client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_2_config.type = PeerConnectionInterface::kRelay;
   client_2_config.presume_writable_when_fully_relayed = true;
 
   ASSERT_TRUE(
@@ -2326,22 +2323,22 @@
   caller()->AddAudioTrack();
 
   // Call getStats, assert there are no candidates.
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> first_report =
+  rtc::scoped_refptr<const RTCStatsReport> first_report =
       caller()->NewGetStats();
   ASSERT_TRUE(first_report);
   auto first_candidate_stats =
-      first_report->GetStatsOfType<webrtc::RTCLocalIceCandidateStats>();
+      first_report->GetStatsOfType<RTCLocalIceCandidateStats>();
   ASSERT_EQ(first_candidate_stats.size(), 0u);
 
   // Create an offer at the caller and set it as remote description on the
   // callee.
   caller()->CreateAndSetAndSignalOffer();
   // Call getStats again, assert there are candidates now.
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> second_report =
+  rtc::scoped_refptr<const RTCStatsReport> second_report =
       caller()->NewGetStats();
   ASSERT_TRUE(second_report);
   auto second_candidate_stats =
-      second_report->GetStatsOfType<webrtc::RTCLocalIceCandidateStats>();
+      second_report->GetStatsOfType<RTCLocalIceCandidateStats>();
   ASSERT_NE(second_candidate_stats.size(), 0u);
 
   // The fake clock ensures that no time has passed so the cache must have been
@@ -2362,17 +2359,17 @@
                              kDefaultTimeout, FakeClock());
 
   // Call getStats, assert there are no candidates.
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> first_report =
+  rtc::scoped_refptr<const RTCStatsReport> first_report =
       caller()->NewGetStats();
   ASSERT_TRUE(first_report);
   auto first_candidate_stats =
-      first_report->GetStatsOfType<webrtc::RTCRemoteIceCandidateStats>();
+      first_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
   ASSERT_EQ(first_candidate_stats.size(), 0u);
 
   // Add a "fake" candidate.
   absl::optional<RTCError> result;
   caller()->pc()->AddIceCandidate(
-      absl::WrapUnique(webrtc::CreateIceCandidate(
+      absl::WrapUnique(CreateIceCandidate(
           "", 0,
           "candidate:2214029314 1 udp 2122260223 127.0.0.1 49152 typ host",
           nullptr)),
@@ -2381,11 +2378,11 @@
   ASSERT_TRUE(result.value().ok());
 
   // Call getStats again, assert there is a remote candidate now.
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> second_report =
+  rtc::scoped_refptr<const RTCStatsReport> second_report =
       caller()->NewGetStats();
   ASSERT_TRUE(second_report);
   auto second_candidate_stats =
-      second_report->GetStatsOfType<webrtc::RTCRemoteIceCandidateStats>();
+      second_report->GetStatsOfType<RTCRemoteIceCandidateStats>();
   ASSERT_EQ(second_candidate_stats.size(), 1u);
 
   // The fake clock ensures that no time has passed so the cache must have been
@@ -2413,22 +2410,22 @@
                    turn_server_2_external_address);
 
   PeerConnectionInterface::RTCConfiguration client_1_config;
-  webrtc::PeerConnectionInterface::IceServer ice_server_1;
+  PeerConnectionInterface::IceServer ice_server_1;
   ice_server_1.urls.push_back("turn:88.88.88.0:3478");
   ice_server_1.username = "test";
   ice_server_1.password = "test";
   client_1_config.servers.push_back(ice_server_1);
-  client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_1_config.type = PeerConnectionInterface::kRelay;
   auto* customizer1 = CreateTurnCustomizer();
   client_1_config.turn_customizer = customizer1;
 
   PeerConnectionInterface::RTCConfiguration client_2_config;
-  webrtc::PeerConnectionInterface::IceServer ice_server_2;
+  PeerConnectionInterface::IceServer ice_server_2;
   ice_server_2.urls.push_back("turn:99.99.99.0:3478");
   ice_server_2.username = "test";
   ice_server_2.password = "test";
   client_2_config.servers.push_back(ice_server_2);
-  client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_2_config.type = PeerConnectionInterface::kRelay;
   auto* customizer2 = CreateTurnCustomizer();
   client_2_config.turn_customizer = customizer2;
 
@@ -2460,18 +2457,18 @@
   CreateTurnServer(turn_server_internal_address, turn_server_external_address,
                    cricket::PROTO_TCP);
 
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back("turn:88.88.88.0:3478?transport=tcp");
   ice_server.username = "test";
   ice_server.password = "test";
 
   PeerConnectionInterface::RTCConfiguration client_1_config;
   client_1_config.servers.push_back(ice_server);
-  client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_1_config.type = PeerConnectionInterface::kRelay;
 
   PeerConnectionInterface::RTCConfiguration client_2_config;
   client_2_config.servers.push_back(ice_server);
-  client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_2_config.type = PeerConnectionInterface::kRelay;
 
   ASSERT_TRUE(
       CreatePeerConnectionWrappersWithConfig(client_1_config, client_2_config));
@@ -2482,7 +2479,7 @@
   callee()->AddAudioVideoTracks();
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kMaxWaitForFramesMs);
 
   MediaExpectations media_expectations;
@@ -2506,20 +2503,20 @@
   CreateTurnServer(turn_server_internal_address, turn_server_external_address,
                    cricket::PROTO_TLS, "88.88.88.0");
 
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
   ice_server.username = "test";
   ice_server.password = "test";
 
   PeerConnectionInterface::RTCConfiguration client_1_config;
   client_1_config.servers.push_back(ice_server);
-  client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_1_config.type = PeerConnectionInterface::kRelay;
 
   PeerConnectionInterface::RTCConfiguration client_2_config;
   client_2_config.servers.push_back(ice_server);
   // Setting the type to kRelay forces the connection to go through a TURN
   // server.
-  client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_2_config.type = PeerConnectionInterface::kRelay;
 
   // Get a copy to the pointer so we can verify calls later.
   rtc::TestCertificateVerifier* client_1_cert_verifier =
@@ -2530,10 +2527,10 @@
   client_2_cert_verifier->verify_certificate_ = true;
 
   // Create the dependencies with the test certificate verifier.
-  webrtc::PeerConnectionDependencies client_1_deps(nullptr);
+  PeerConnectionDependencies client_1_deps(nullptr);
   client_1_deps.tls_cert_verifier =
       std::unique_ptr<rtc::TestCertificateVerifier>(client_1_cert_verifier);
-  webrtc::PeerConnectionDependencies client_2_deps(nullptr);
+  PeerConnectionDependencies client_2_deps(nullptr);
   client_2_deps.tls_cert_verifier =
       std::unique_ptr<rtc::TestCertificateVerifier>(client_2_cert_verifier);
 
@@ -2644,7 +2641,7 @@
   ASSERT_GT(receiver->GetParameters().encodings.size(), 0u);
   EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
             sources[0].source_id());
-  EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
+  EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
 }
 
 TEST_P(PeerConnectionIntegrationTest, GetSourcesVideo) {
@@ -2665,7 +2662,7 @@
   ASSERT_GT(sources.size(), 0u);
   EXPECT_EQ(receiver->GetParameters().encodings[0].ssrc,
             sources[0].source_id());
-  EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
+  EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
 }
 
 TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesAudio) {
@@ -2684,7 +2681,7 @@
                    })(),
                    kDefaultTimeout);
   ASSERT_GT(sources.size(), 0u);
-  EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
+  EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
 }
 
 TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetSourcesVideo) {
@@ -2703,7 +2700,7 @@
                    })(),
                    kDefaultTimeout);
   ASSERT_GT(sources.size(), 0u);
-  EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
+  EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
 }
 
 // Similar to the above test, except instead of waiting until GetSources() is
@@ -2728,7 +2725,7 @@
   std::vector<RtpSource> sources = receiver->GetSources();
   // SSRC history must not be cleared since the reception of the first frame.
   ASSERT_GT(sources.size(), 0u);
-  EXPECT_EQ(webrtc::RtpSourceType::SSRC, sources[0].source_type());
+  EXPECT_EQ(RtpSourceType::SSRC, sources[0].source_type());
 }
 
 TEST_P(PeerConnectionIntegrationTest, UnsignaledSsrcGetParametersAudio) {
@@ -2791,9 +2788,9 @@
   ConnectFakeSignaling();
 
   // Add track using stream 1, do offer/answer.
-  rtc::scoped_refptr<webrtc::AudioTrackInterface> track =
+  rtc::scoped_refptr<AudioTrackInterface> track =
       caller()->CreateLocalAudioTrack();
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> sender =
+  rtc::scoped_refptr<RtpSenderInterface> sender =
       caller()->AddTrack(track, {"stream_1"});
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
@@ -2825,8 +2822,8 @@
       .WillByDefault(::testing::Return(true));
   EXPECT_CALL(*output, Write(::testing::A<absl::string_view>()))
       .Times(::testing::AtLeast(1));
-  EXPECT_TRUE(caller()->pc()->StartRtcEventLog(
-      std::move(output), webrtc::RtcEventLog::kImmediateOutput));
+  EXPECT_TRUE(caller()->pc()->StartRtcEventLog(std::move(output),
+                                               RtcEventLog::kImmediateOutput));
 
   caller()->AddAudioVideoTracks();
   caller()->CreateAndSetAndSignalOffer();
@@ -2900,8 +2897,7 @@
 
 double GetAudioEnergyStat(PeerConnectionIntegrationWrapper* pc) {
   auto report = pc->NewGetStats();
-  auto inbound_rtps =
-      report->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>();
+  auto inbound_rtps = report->GetStatsOfType<RTCInboundRtpStreamStats>();
   RTC_CHECK(!inbound_rtps.empty());
   auto* inbound_rtp = inbound_rtps[0];
   if (!inbound_rtp->total_audio_energy.is_defined()) {
@@ -2974,20 +2970,20 @@
   ASSERT_TRUE_WAIT(DtlsConnected(), kDefaultTimeout);
   ASSERT_NE(nullptr, caller()->event_log_factory());
   ASSERT_NE(nullptr, callee()->event_log_factory());
-  webrtc::FakeRtcEventLog* caller_event_log =
+  FakeRtcEventLog* caller_event_log =
       caller()->event_log_factory()->last_log_created();
-  webrtc::FakeRtcEventLog* callee_event_log =
+  FakeRtcEventLog* callee_event_log =
       callee()->event_log_factory()->last_log_created();
   ASSERT_NE(nullptr, caller_event_log);
   ASSERT_NE(nullptr, callee_event_log);
-  int caller_ice_config_count = caller_event_log->GetEventCount(
-      webrtc::RtcEvent::Type::IceCandidatePairConfig);
-  int caller_ice_event_count = caller_event_log->GetEventCount(
-      webrtc::RtcEvent::Type::IceCandidatePairEvent);
-  int callee_ice_config_count = callee_event_log->GetEventCount(
-      webrtc::RtcEvent::Type::IceCandidatePairConfig);
-  int callee_ice_event_count = callee_event_log->GetEventCount(
-      webrtc::RtcEvent::Type::IceCandidatePairEvent);
+  int caller_ice_config_count =
+      caller_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairConfig);
+  int caller_ice_event_count =
+      caller_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairEvent);
+  int callee_ice_config_count =
+      callee_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairConfig);
+  int callee_ice_event_count =
+      callee_event_log->GetEventCount(RtcEvent::Type::IceCandidatePairEvent);
   EXPECT_LT(0, caller_ice_config_count);
   EXPECT_LT(0, caller_ice_event_count);
   EXPECT_LT(0, callee_ice_config_count);
@@ -3001,20 +2997,20 @@
 
   CreateTurnServer(turn_server_internal_address, turn_server_external_address);
 
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back("turn:88.88.88.0:3478");
   ice_server.username = "test";
   ice_server.password = "test";
 
   PeerConnectionInterface::RTCConfiguration caller_config;
   caller_config.servers.push_back(ice_server);
-  caller_config.type = webrtc::PeerConnectionInterface::kRelay;
+  caller_config.type = PeerConnectionInterface::kRelay;
   caller_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
   caller_config.surface_ice_candidates_on_ice_transport_type_changed = true;
 
   PeerConnectionInterface::RTCConfiguration callee_config;
   callee_config.servers.push_back(ice_server);
-  callee_config.type = webrtc::PeerConnectionInterface::kRelay;
+  callee_config.type = PeerConnectionInterface::kRelay;
   callee_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
   callee_config.surface_ice_candidates_on_ice_transport_type_changed = true;
 
@@ -3031,9 +3027,9 @@
   // kIceGatheringComplete (see
   // P2PTransportChannel::OnCandidatesAllocationDone), and consequently not
   // kIceConnectionComplete.
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  caller()->ice_connection_state(), kDefaultTimeout);
-  EXPECT_EQ_WAIT(webrtc::PeerConnectionInterface::kIceConnectionConnected,
+  EXPECT_EQ_WAIT(PeerConnectionInterface::kIceConnectionConnected,
                  callee()->ice_connection_state(), kDefaultTimeout);
   // Note that we cannot use the metric
   // `WebRTC.PeerConnection.CandidatePairType_UDP` in this test since this
@@ -3046,7 +3042,7 @@
 
   // Loosen the caller's candidate filter.
   caller_config = caller()->pc()->GetConfiguration();
-  caller_config.type = webrtc::PeerConnectionInterface::kAll;
+  caller_config.type = PeerConnectionInterface::kAll;
   caller()->pc()->SetConfiguration(caller_config);
   // We should have gathered a new host candidate.
   EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE,
@@ -3054,7 +3050,7 @@
 
   // Loosen the callee's candidate filter.
   callee_config = callee()->pc()->GetConfiguration();
-  callee_config.type = webrtc::PeerConnectionInterface::kAll;
+  callee_config.type = PeerConnectionInterface::kAll;
   callee()->pc()->SetConfiguration(callee_config);
   EXPECT_EQ_WAIT(cricket::LOCAL_PORT_TYPE,
                  callee()->last_candidate_gathered().type(), kDefaultTimeout);
@@ -3084,19 +3080,19 @@
 
   CreateTurnServer(turn_server_internal_address, turn_server_external_address);
 
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back("turn:88.88.88.0:3478");
   ice_server.username = "test";
   ice_server.password = "123";
 
   PeerConnectionInterface::RTCConfiguration caller_config;
   caller_config.servers.push_back(ice_server);
-  caller_config.type = webrtc::PeerConnectionInterface::kRelay;
+  caller_config.type = PeerConnectionInterface::kRelay;
   caller_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
 
   PeerConnectionInterface::RTCConfiguration callee_config;
   callee_config.servers.push_back(ice_server);
-  callee_config.type = webrtc::PeerConnectionInterface::kRelay;
+  callee_config.type = PeerConnectionInterface::kRelay;
   callee_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
 
   ASSERT_TRUE(
@@ -3115,19 +3111,19 @@
 }
 
 TEST_P(PeerConnectionIntegrationTest, OnIceCandidateErrorWithEmptyAddress) {
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back("turn:127.0.0.1:3478?transport=tcp");
   ice_server.username = "test";
   ice_server.password = "test";
 
   PeerConnectionInterface::RTCConfiguration caller_config;
   caller_config.servers.push_back(ice_server);
-  caller_config.type = webrtc::PeerConnectionInterface::kRelay;
+  caller_config.type = PeerConnectionInterface::kRelay;
   caller_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
 
   PeerConnectionInterface::RTCConfiguration callee_config;
   callee_config.servers.push_back(ice_server);
-  callee_config.type = webrtc::PeerConnectionInterface::kRelay;
+  callee_config.type = PeerConnectionInterface::kRelay;
   callee_config.continual_gathering_policy = PeerConnection::GATHER_CONTINUALLY;
 
   ASSERT_TRUE(
@@ -3697,7 +3693,7 @@
       CreateOneDirectionalPeerConnectionWrappers(/*caller_to_callee=*/true));
   ConnectFakeSignaling();
   // Add one-directional video, from caller to callee.
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> caller_track =
+  rtc::scoped_refptr<VideoTrackInterface> caller_track =
       caller()->CreateLocalVideoTrack();
   auto sender = caller()->AddTrack(caller_track);
   PeerConnectionInterface::RTCOfferAnswerOptions options;
@@ -3722,7 +3718,7 @@
 }
 
 int NacksReceivedCount(PeerConnectionIntegrationWrapper& pc) {
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> report = pc.NewGetStats();
+  rtc::scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
   auto sender_stats = report->GetStatsOfType<RTCOutboundRtpStreamStats>();
   if (sender_stats.size() != 1) {
     ADD_FAILURE();
@@ -3735,7 +3731,7 @@
 }
 
 int NacksSentCount(PeerConnectionIntegrationWrapper& pc) {
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> report = pc.NewGetStats();
+  rtc::scoped_refptr<const RTCStatsReport> report = pc.NewGetStats();
   auto receiver_stats = report->GetStatsOfType<RTCInboundRtpStreamStats>();
   if (receiver_stats.size() != 1) {
     ADD_FAILURE();
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 2dbc6f5..c057e55 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -474,8 +474,7 @@
 
 // Get the ufrags out of an SDP blob. Useful for testing ICE restart
 // behavior.
-std::vector<std::string> GetUfrags(
-    const webrtc::SessionDescriptionInterface* desc) {
+std::vector<std::string> GetUfrags(const SessionDescriptionInterface* desc) {
   std::vector<std::string> ufrags;
   for (const cricket::TransportInfo& info :
        desc->description()->transport_infos()) {
@@ -544,21 +543,19 @@
       StreamCollection::Create());
 
   for (int i = 0; i < number_of_streams; ++i) {
-    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
-        webrtc::MediaStream::Create(kStreams[i]));
+    rtc::scoped_refptr<MediaStreamInterface> stream(
+        MediaStream::Create(kStreams[i]));
 
     for (int j = 0; j < tracks_per_stream; ++j) {
       // Add a local audio track.
-      rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
-          webrtc::AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j],
-                                     nullptr));
+      rtc::scoped_refptr<AudioTrackInterface> audio_track(
+          AudioTrack::Create(kAudioTracks[i * tracks_per_stream + j], nullptr));
       stream->AddTrack(audio_track);
 
       // Add a local video track.
-      rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-          webrtc::VideoTrack::Create(kVideoTracks[i * tracks_per_stream + j],
-                                     webrtc::FakeVideoTrackSource::Create(),
-                                     rtc::Thread::Current()));
+      rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
+          kVideoTracks[i * tracks_per_stream + j],
+          FakeVideoTrackSource::Create(), rtc::Thread::Current()));
       stream->AddTrack(video_track);
     }
 
@@ -578,10 +575,10 @@
     if (s1->at(i)->id() != s2->at(i)->id()) {
       return false;
     }
-    webrtc::AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks();
-    webrtc::AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks();
-    webrtc::VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks();
-    webrtc::VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks();
+    AudioTrackVector audio_tracks1 = s1->at(i)->GetAudioTracks();
+    AudioTrackVector audio_tracks2 = s2->at(i)->GetAudioTracks();
+    VideoTrackVector video_tracks1 = s1->at(i)->GetVideoTracks();
+    VideoTrackVector video_tracks2 = s2->at(i)->GetVideoTracks();
 
     if (audio_tracks1.size() != audio_tracks2.size()) {
       return false;
@@ -630,7 +627,7 @@
 // constraints are propagated into the PeerConnection's MediaConfig. These
 // settings are intended for MediaChannel constructors, but that is not
 // exercised by these unittest.
-class PeerConnectionFactoryForTest : public webrtc::PeerConnectionFactory {
+class PeerConnectionFactoryForTest : public PeerConnectionFactory {
  public:
   static rtc::scoped_refptr<PeerConnectionFactoryForTest>
   CreatePeerConnectionFactoryForTest() {
@@ -665,7 +662,7 @@
         main_(vss_.get()),
         sdp_semantics_(sdp_semantics) {
 #ifdef WEBRTC_ANDROID
-    webrtc::InitializeAndroidObjects();
+    InitializeAndroidObjects();
 #endif
   }
 
@@ -673,22 +670,16 @@
     // Use fake audio capture module since we're only testing the interface
     // level, and using a real one could make tests flaky when run in parallel.
     fake_audio_capture_module_ = FakeAudioCaptureModule::Create();
-    pc_factory_ = webrtc::CreatePeerConnectionFactory(
+    pc_factory_ = CreatePeerConnectionFactory(
         rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
-        rtc::scoped_refptr<webrtc::AudioDeviceModule>(
-            fake_audio_capture_module_),
-        webrtc::CreateBuiltinAudioEncoderFactory(),
-        webrtc::CreateBuiltinAudioDecoderFactory(),
-        std::make_unique<webrtc::VideoEncoderFactoryTemplate<
-            webrtc::LibvpxVp8EncoderTemplateAdapter,
-            webrtc::LibvpxVp9EncoderTemplateAdapter,
-            webrtc::OpenH264EncoderTemplateAdapter,
-            webrtc::LibaomAv1EncoderTemplateAdapter>>(),
-        std::make_unique<webrtc::VideoDecoderFactoryTemplate<
-            webrtc::LibvpxVp8DecoderTemplateAdapter,
-            webrtc::LibvpxVp9DecoderTemplateAdapter,
-            webrtc::OpenH264DecoderTemplateAdapter,
-            webrtc::Dav1dDecoderTemplateAdapter>>(),
+        rtc::scoped_refptr<AudioDeviceModule>(fake_audio_capture_module_),
+        CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(),
+        std::make_unique<VideoEncoderFactoryTemplate<
+            LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
+            OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
+        std::make_unique<VideoDecoderFactoryTemplate<
+            LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
+            OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
         nullptr /* audio_mixer */, nullptr /* audio_processing */);
     ASSERT_TRUE(pc_factory_);
   }
@@ -946,8 +937,7 @@
 
   // Call the standards-compliant GetStats function.
   bool DoGetRTCStats() {
-    auto callback =
-        rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
+    auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
     pc_->GetStats(callback.get());
     EXPECT_TRUE_WAIT(callback->called(), kTimeout);
     return callback->called();
@@ -987,14 +977,14 @@
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     std::unique_ptr<SessionDescriptionInterface> remote_offer(
-        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+        CreateSessionDescription(SdpType::kOffer, sdp));
     EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
 
   void CreateAndSetRemoteOffer(const std::string& sdp) {
     std::unique_ptr<SessionDescriptionInterface> remote_offer(
-        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+        CreateSessionDescription(SdpType::kOffer, sdp));
     EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
@@ -1013,7 +1003,7 @@
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     std::unique_ptr<SessionDescriptionInterface> new_answer(
-        webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+        CreateSessionDescription(SdpType::kAnswer, sdp));
     EXPECT_TRUE(DoSetLocalDescription(std::move(new_answer)));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
   }
@@ -1025,7 +1015,7 @@
     std::string sdp;
     EXPECT_TRUE(answer->ToString(&sdp));
     std::unique_ptr<SessionDescriptionInterface> pr_answer(
-        webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+        CreateSessionDescription(SdpType::kPrAnswer, sdp));
     EXPECT_TRUE(DoSetLocalDescription(std::move(pr_answer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalPrAnswer, observer_.state_);
   }
@@ -1050,7 +1040,7 @@
     std::string sdp;
     EXPECT_TRUE(offer->ToString(&sdp));
     std::unique_ptr<SessionDescriptionInterface> new_offer(
-        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+        CreateSessionDescription(SdpType::kOffer, sdp));
 
     EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
@@ -1060,7 +1050,7 @@
 
   void CreateAnswerAsRemoteDescription(const std::string& sdp) {
     std::unique_ptr<SessionDescriptionInterface> answer(
-        webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+        CreateSessionDescription(SdpType::kAnswer, sdp));
     ASSERT_TRUE(answer);
     EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
@@ -1068,12 +1058,12 @@
 
   void CreatePrAnswerAndAnswerAsRemoteDescription(const std::string& sdp) {
     std::unique_ptr<SessionDescriptionInterface> pr_answer(
-        webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+        CreateSessionDescription(SdpType::kPrAnswer, sdp));
     ASSERT_TRUE(pr_answer);
     EXPECT_TRUE(DoSetRemoteDescription(std::move(pr_answer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemotePrAnswer, observer_.state_);
     std::unique_ptr<SessionDescriptionInterface> answer(
-        webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+        CreateSessionDescription(SdpType::kAnswer, sdp));
     ASSERT_TRUE(answer);
     EXPECT_TRUE(DoSetRemoteDescription(std::move(answer)));
     EXPECT_EQ(PeerConnectionInterface::kStable, observer_.state_);
@@ -1117,8 +1107,8 @@
 
     std::string mediastream_id = kStreams[0];
 
-    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
-        webrtc::MediaStream::Create(mediastream_id));
+    rtc::scoped_refptr<MediaStreamInterface> stream(
+        MediaStream::Create(mediastream_id));
     reference_collection_->AddStream(stream);
 
     if (number_of_audio_tracks > 0) {
@@ -1142,22 +1132,20 @@
     }
 
     return std::unique_ptr<SessionDescriptionInterface>(
-        webrtc::CreateSessionDescription(SdpType::kOffer, sdp_ms1));
+        CreateSessionDescription(SdpType::kOffer, sdp_ms1));
   }
 
   void AddAudioTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
-    rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
-        webrtc::AudioTrack::Create(track_id, nullptr));
+    rtc::scoped_refptr<AudioTrackInterface> audio_track(
+        AudioTrack::Create(track_id, nullptr));
     ASSERT_TRUE(stream->AddTrack(audio_track));
   }
 
   void AddVideoTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
-    rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-        webrtc::VideoTrack::Create(track_id,
-                                   webrtc::FakeVideoTrackSource::Create(),
-                                   rtc::Thread::Current()));
+    rtc::scoped_refptr<VideoTrackInterface> video_track(VideoTrack::Create(
+        track_id, FakeVideoTrackSource::Create(), rtc::Thread::Current()));
     ASSERT_TRUE(stream->AddTrack(video_track));
   }
 
@@ -1217,7 +1205,7 @@
     std::string sdp;
     EXPECT_TRUE((*desc)->ToString(&sdp));
     std::unique_ptr<SessionDescriptionInterface> remote_offer(
-        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+        CreateSessionDescription(SdpType::kOffer, sdp));
     EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveRemoteOffer, observer_.state_);
   }
@@ -1230,7 +1218,7 @@
     std::string sdp;
     EXPECT_TRUE((*desc)->ToString(&sdp));
     std::unique_ptr<SessionDescriptionInterface> new_offer(
-        webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+        CreateSessionDescription(SdpType::kOffer, sdp));
 
     EXPECT_TRUE(DoSetLocalDescription(std::move(new_offer)));
     EXPECT_EQ(PeerConnectionInterface::kHaveLocalOffer, observer_.state_);
@@ -1266,13 +1254,13 @@
 
   rtc::SocketServer* socket_server() const { return vss_.get(); }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::AutoSocketServerThread main_;
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   cricket::FakePortAllocator* port_allocator_ = nullptr;
   FakeRTCCertificateGenerator* fake_certificate_generator_ = nullptr;
-  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
   rtc::scoped_refptr<PeerConnectionInterface> pc_;
   MockPeerConnectionObserver observer_;
   rtc::scoped_refptr<StreamCollection> reference_collection_;
@@ -1392,22 +1380,19 @@
   config.prune_turn_ports = true;
 
   // Create the PC factory and PC with the above config.
-  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory(
-      webrtc::CreatePeerConnectionFactory(
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory(
+      CreatePeerConnectionFactory(
           rtc::Thread::Current(), rtc::Thread::Current(),
           rtc::Thread::Current(), fake_audio_capture_module_,
-          webrtc::CreateBuiltinAudioEncoderFactory(),
-          webrtc::CreateBuiltinAudioDecoderFactory(),
-          std::make_unique<webrtc::VideoEncoderFactoryTemplate<
-              webrtc::LibvpxVp8EncoderTemplateAdapter,
-              webrtc::LibvpxVp9EncoderTemplateAdapter,
-              webrtc::OpenH264EncoderTemplateAdapter,
-              webrtc::LibaomAv1EncoderTemplateAdapter>>(),
-          std::make_unique<webrtc::VideoDecoderFactoryTemplate<
-              webrtc::LibvpxVp8DecoderTemplateAdapter,
-              webrtc::LibvpxVp9DecoderTemplateAdapter,
-              webrtc::OpenH264DecoderTemplateAdapter,
-              webrtc::Dav1dDecoderTemplateAdapter>>(),
+          CreateBuiltinAudioEncoderFactory(),
+          CreateBuiltinAudioDecoderFactory(),
+          std::make_unique<VideoEncoderFactoryTemplate<
+              LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
+              OpenH264EncoderTemplateAdapter,
+              LibaomAv1EncoderTemplateAdapter>>(),
+          std::make_unique<VideoDecoderFactoryTemplate<
+              LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
+              OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
           nullptr /* audio_mixer */, nullptr /* audio_processing */));
   PeerConnectionDependencies pc_dependencies(&observer_);
   pc_dependencies.allocator = std::move(port_allocator);
@@ -1424,7 +1409,7 @@
   EXPECT_TRUE(raw_port_allocator->flags() & cricket::PORTALLOCATOR_DISABLE_TCP);
   EXPECT_TRUE(raw_port_allocator->flags() &
               cricket::PORTALLOCATOR_DISABLE_COSTLY_NETWORKS);
-  EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY,
+  EXPECT_EQ(PRUNE_BASED_ON_PRIORITY,
             raw_port_allocator->turn_port_prune_policy());
 }
 
@@ -1446,8 +1431,7 @@
 TEST_P(PeerConnectionInterfaceTest, GetConfigurationAfterSetConfiguration) {
   PeerConnectionInterface::RTCConfiguration starting_config;
   starting_config.sdp_semantics = sdp_semantics_;
-  starting_config.bundle_policy =
-      webrtc::PeerConnection::kBundlePolicyMaxBundle;
+  starting_config.bundle_policy = PeerConnection::kBundlePolicyMaxBundle;
   CreatePeerConnection(starting_config);
 
   PeerConnectionInterface::RTCConfiguration config = pc_->GetConfiguration();
@@ -1978,7 +1962,7 @@
   RTCConfiguration rtc_config;
   CreatePeerConnection(rtc_config);
 
-  webrtc::DataChannelInit config;
+  DataChannelInit config;
   auto channel = pc_->CreateDataChannelOrError("1", &config);
   EXPECT_TRUE(channel.ok());
   EXPECT_TRUE(channel.value()->reliable());
@@ -2010,7 +1994,7 @@
   RTCConfiguration rtc_config;
   CreatePeerConnection(rtc_config);
   pc_->Close();
-  webrtc::DataChannelInit config;
+  DataChannelInit config;
   auto ret = pc_->CreateDataChannelOrError("1", &config);
   ASSERT_FALSE(ret.ok());
   EXPECT_EQ(ret.error().type(), RTCErrorType::INVALID_STATE);
@@ -2022,7 +2006,7 @@
   RTCConfiguration rtc_config;
   CreatePeerConnection(rtc_config);
 
-  webrtc::DataChannelInit config;
+  DataChannelInit config;
   config.maxRetransmitTime = -1;
   config.maxRetransmits = -1;
   auto channel = pc_->CreateDataChannelOrError("1", &config);
@@ -2037,7 +2021,7 @@
   CreatePeerConnection(rtc_config);
 
   std::string label = "test";
-  webrtc::DataChannelInit config;
+  DataChannelInit config;
   config.maxRetransmits = 0;
   config.maxRetransmitTime = 0;
 
@@ -2052,7 +2036,7 @@
   RTCConfiguration rtc_config;
   CreatePeerConnection(rtc_config);
 
-  webrtc::DataChannelInit config;
+  DataChannelInit config;
 
   config.id = 1;
   config.negotiated = true;
@@ -2106,7 +2090,7 @@
   std::string sdp;
   EXPECT_TRUE(pc_->local_description()->ToString(&sdp));
   std::unique_ptr<SessionDescriptionInterface> answer(
-      webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+      CreateSessionDescription(SdpType::kAnswer, sdp));
   ASSERT_TRUE(answer);
   cricket::ContentInfo* data_info =
       cricket::GetFirstDataContent(answer->description());
@@ -2125,8 +2109,7 @@
   AddAudioTrack("audio_label");
   AddVideoTrack("video_label");
   std::unique_ptr<SessionDescriptionInterface> desc(
-      webrtc::CreateSessionDescription(SdpType::kOffer,
-                                       webrtc::kFireFoxSdpOffer, nullptr));
+      CreateSessionDescription(SdpType::kOffer, kFireFoxSdpOffer, nullptr));
   EXPECT_TRUE(DoSetSessionDescription(std::move(desc), false));
   CreateAnswerAsLocalDescription();
   ASSERT_TRUE(pc_->local_description() != nullptr);
@@ -2163,8 +2146,7 @@
   EXPECT_EQ_WAIT(1, fake_certificate_generator_->generated_certificates(),
                  kTimeout);
   std::unique_ptr<SessionDescriptionInterface> desc(
-      webrtc::CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp,
-                                       nullptr));
+      CreateSessionDescription(SdpType::kOffer, kDtlsSdesFallbackSdp, nullptr));
   EXPECT_FALSE(DoSetSessionDescription(std::move(desc), /*local=*/false));
 }
 
@@ -2177,18 +2159,17 @@
   CreateOfferAsLocalDescription();
 
   const char* answer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
-                                ? webrtc::kAudioSdpPlanB
-                                : webrtc::kAudioSdpUnifiedPlan);
+                                ? kAudioSdpPlanB
+                                : kAudioSdpUnifiedPlan);
   std::unique_ptr<SessionDescriptionInterface> answer(
-      webrtc::CreateSessionDescription(SdpType::kAnswer, answer_sdp, nullptr));
+      CreateSessionDescription(SdpType::kAnswer, answer_sdp, nullptr));
   EXPECT_TRUE(DoSetSessionDescription(std::move(answer), false));
 
-  const char* reoffer_sdp =
-      (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
-           ? webrtc::kAudioSdpWithUnsupportedCodecsPlanB
-           : webrtc::kAudioSdpWithUnsupportedCodecsUnifiedPlan);
+  const char* reoffer_sdp = (sdp_semantics_ == SdpSemantics::kPlanB_DEPRECATED
+                                 ? kAudioSdpWithUnsupportedCodecsPlanB
+                                 : kAudioSdpWithUnsupportedCodecsUnifiedPlan);
   std::unique_ptr<SessionDescriptionInterface> updated_offer(
-      webrtc::CreateSessionDescription(SdpType::kOffer, reoffer_sdp, nullptr));
+      CreateSessionDescription(SdpType::kOffer, reoffer_sdp, nullptr));
   EXPECT_TRUE(DoSetSessionDescription(std::move(updated_offer), false));
   CreateAnswerAsLocalDescription();
 }
@@ -2275,12 +2256,11 @@
   config.prune_turn_ports = false;
   CreatePeerConnection(config);
   config = pc_->GetConfiguration();
-  EXPECT_EQ(webrtc::NO_PRUNE, port_allocator_->turn_port_prune_policy());
+  EXPECT_EQ(NO_PRUNE, port_allocator_->turn_port_prune_policy());
 
   config.prune_turn_ports = true;
   EXPECT_TRUE(pc_->SetConfiguration(config).ok());
-  EXPECT_EQ(webrtc::PRUNE_BASED_ON_PRIORITY,
-            port_allocator_->turn_port_prune_policy());
+  EXPECT_EQ(PRUNE_BASED_ON_PRIORITY, port_allocator_->turn_port_prune_policy());
 }
 
 // Test that the ice check interval can be changed. This does not verify that
@@ -2549,12 +2529,12 @@
   std::string sdp;
   ASSERT_TRUE(pc_->remote_description()->ToString(&sdp));
   std::unique_ptr<SessionDescriptionInterface> remote_offer(
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+      CreateSessionDescription(SdpType::kOffer, sdp));
   EXPECT_FALSE(DoSetRemoteDescription(std::move(remote_offer)));
 
   ASSERT_TRUE(pc_->local_description()->ToString(&sdp));
   std::unique_ptr<SessionDescriptionInterface> local_offer(
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+      CreateSessionDescription(SdpType::kOffer, sdp));
   EXPECT_FALSE(DoSetLocalDescription(std::move(local_offer)));
 }
 
@@ -2614,10 +2594,10 @@
                                        reference_collection_.get()));
   rtc::scoped_refptr<AudioTrackInterface> audio_track2 =
       observer_.remote_streams()->at(0)->GetAudioTracks()[1];
-  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, audio_track2->state());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive, audio_track2->state());
   rtc::scoped_refptr<VideoTrackInterface> video_track2 =
       observer_.remote_streams()->at(0)->GetVideoTracks()[1];
-  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track2->state());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track2->state());
 
   // Remove the extra audio and video tracks.
   std::unique_ptr<SessionDescriptionInterface> desc_ms2 =
@@ -2631,10 +2611,10 @@
   EXPECT_TRUE(CompareStreamCollections(observer_.remote_streams(),
                                        reference_collection_.get()));
   // Track state may be updated asynchronously.
-  EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
-                 audio_track2->state(), kTimeout);
-  EXPECT_EQ_WAIT(webrtc::MediaStreamTrackInterface::kEnded,
-                 video_track2->state(), kTimeout);
+  EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, audio_track2->state(),
+                 kTimeout);
+  EXPECT_EQ_WAIT(MediaStreamTrackInterface::kEnded, video_track2->state(),
+                 kTimeout);
 }
 
 // This tests that remote tracks are ended if a local session description is set
@@ -2652,7 +2632,7 @@
 
   rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio =
       audio_receiver->track();
-  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, remote_audio->state());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_audio->state());
   rtc::scoped_refptr<MediaStreamTrackInterface> remote_video =
       video_receiver->track();
   EXPECT_EQ(MediaStreamTrackInterface::kLive, remote_video->state());
@@ -2696,8 +2676,8 @@
   remote_stream->RemoveTrack(remote_stream->GetAudioTracks()[0]);
 
   std::unique_ptr<SessionDescriptionInterface> local_answer(
-      webrtc::CreateSessionDescription(SdpType::kAnswer,
-                                       GetSdpStringWithStream1(), nullptr));
+      CreateSessionDescription(SdpType::kAnswer, GetSdpStringWithStream1(),
+                               nullptr));
   cricket::ContentInfo* video_info =
       local_answer->description()->GetContentByName("video");
   video_info->rejected = true;
@@ -2986,9 +2966,9 @@
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
   // Grab a copy of the offer before it gets passed into the PC.
   std::unique_ptr<SessionDescriptionInterface> modified_offer =
-      webrtc::CreateSessionDescription(
-          webrtc::SdpType::kOffer, offer->session_id(),
-          offer->session_version(), offer->description()->Clone());
+      CreateSessionDescription(SdpType::kOffer, offer->session_id(),
+                               offer->session_version(),
+                               offer->description()->Clone());
   EXPECT_TRUE(DoSetLocalDescription(std::move(offer)));
 
   auto senders = pc_->GetSenders();
@@ -3044,8 +3024,8 @@
   EXPECT_TRUE(ContainsSender(senders, kVideoTracks[0], kStreams[0]));
 
   // Add a new MediaStream but with the same tracks as in the first stream.
-  rtc::scoped_refptr<webrtc::MediaStreamInterface> stream_1(
-      webrtc::MediaStream::Create(kStreams[1]));
+  rtc::scoped_refptr<MediaStreamInterface> stream_1(
+      MediaStream::Create(kStreams[1]));
   stream_1->AddTrack(stream_collection->at(0)->GetVideoTracks()[0]);
   stream_1->AddTrack(stream_collection->at(0)->GetAudioTracks()[0]);
   pc_->AddStream(stream_1.get());
@@ -3166,9 +3146,9 @@
   EXPECT_TRUE(pc_->SetConfiguration(config).ok());
 
   // Do ICE restart for the first m= section, initiated by remote peer.
-  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_offer(
-      webrtc::CreateSessionDescription(SdpType::kOffer,
-                                       GetSdpStringWithStream1(), nullptr));
+  std::unique_ptr<SessionDescriptionInterface> remote_offer(
+      CreateSessionDescription(SdpType::kOffer, GetSdpStringWithStream1(),
+                               nullptr));
   ASSERT_TRUE(remote_offer);
   remote_offer->description()->transport_infos()[0].description.ice_ufrag =
       "modified";
@@ -3214,7 +3194,7 @@
 
   // Set remote pranswer.
   std::unique_ptr<SessionDescriptionInterface> remote_pranswer(
-      webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+      CreateSessionDescription(SdpType::kPrAnswer, sdp));
   SessionDescriptionInterface* remote_pranswer_ptr = remote_pranswer.get();
   EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_pranswer)));
   EXPECT_EQ(local_offer_ptr, pc_->pending_local_description());
@@ -3224,7 +3204,7 @@
 
   // Set remote answer.
   std::unique_ptr<SessionDescriptionInterface> remote_answer(
-      webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+      CreateSessionDescription(SdpType::kAnswer, sdp));
   SessionDescriptionInterface* remote_answer_ptr = remote_answer.get();
   EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_answer)));
   EXPECT_EQ(nullptr, pc_->pending_local_description());
@@ -3234,7 +3214,7 @@
 
   // Set remote offer.
   std::unique_ptr<SessionDescriptionInterface> remote_offer(
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp));
+      CreateSessionDescription(SdpType::kOffer, sdp));
   SessionDescriptionInterface* remote_offer_ptr = remote_offer.get();
   EXPECT_TRUE(DoSetRemoteDescription(std::move(remote_offer)));
   EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
@@ -3244,7 +3224,7 @@
 
   // Set local pranswer.
   std::unique_ptr<SessionDescriptionInterface> local_pranswer(
-      webrtc::CreateSessionDescription(SdpType::kPrAnswer, sdp));
+      CreateSessionDescription(SdpType::kPrAnswer, sdp));
   SessionDescriptionInterface* local_pranswer_ptr = local_pranswer.get();
   EXPECT_TRUE(DoSetLocalDescription(std::move(local_pranswer)));
   EXPECT_EQ(remote_offer_ptr, pc_->pending_remote_description());
@@ -3254,7 +3234,7 @@
 
   // Set local answer.
   std::unique_ptr<SessionDescriptionInterface> local_answer(
-      webrtc::CreateSessionDescription(SdpType::kAnswer, sdp));
+      CreateSessionDescription(SdpType::kAnswer, sdp));
   SessionDescriptionInterface* local_answer_ptr = local_answer.get();
   EXPECT_TRUE(DoSetLocalDescription(std::move(local_answer)));
   EXPECT_EQ(nullptr, pc_->pending_remote_description());
@@ -3273,9 +3253,8 @@
   // The RtcEventLog will be reset when the PeerConnection is closed.
   pc_->Close();
 
-  EXPECT_FALSE(
-      pc_->StartRtcEventLog(std::make_unique<webrtc::RtcEventLogOutputNull>(),
-                            webrtc::RtcEventLog::kImmediateOutput));
+  EXPECT_FALSE(pc_->StartRtcEventLog(std::make_unique<RtcEventLogOutputNull>(),
+                                     RtcEventLog::kImmediateOutput));
   pc_->StopRtcEventLog();
 }
 
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index f08474e..796520f 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -82,9 +82,9 @@
 using ::testing::Values;
 
 cricket::MediaSendChannelInterface* SendChannelInternal(
-    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
-  auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
-      webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
+    rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+  auto transceiver_with_internal = static_cast<
+      rtc::RefCountedObject<RtpTransceiverProxyWithInternal<RtpTransceiver>>*>(
       transceiver.get());
   auto transceiver_internal =
       static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
@@ -92,9 +92,9 @@
 }
 
 cricket::MediaReceiveChannelInterface* ReceiveChannelInternal(
-    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
-  auto transceiver_with_internal = static_cast<rtc::RefCountedObject<
-      webrtc::RtpTransceiverProxyWithInternal<webrtc::RtpTransceiver>>*>(
+    rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
+  auto transceiver_with_internal = static_cast<
+      rtc::RefCountedObject<RtpTransceiverProxyWithInternal<RtpTransceiver>>*>(
       transceiver.get());
   auto transceiver_internal =
       static_cast<RtpTransceiver*>(transceiver_with_internal->internal());
@@ -102,22 +102,22 @@
 }
 
 cricket::FakeVideoMediaSendChannel* VideoMediaSendChannel(
-    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+    rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
   return static_cast<cricket::FakeVideoMediaSendChannel*>(
       SendChannelInternal(transceiver));
 }
 cricket::FakeVideoMediaReceiveChannel* VideoMediaReceiveChannel(
-    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+    rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
   return static_cast<cricket::FakeVideoMediaReceiveChannel*>(
       ReceiveChannelInternal(transceiver));
 }
 cricket::FakeVoiceMediaSendChannel* VoiceMediaSendChannel(
-    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+    rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
   return static_cast<cricket::FakeVoiceMediaSendChannel*>(
       SendChannelInternal(transceiver));
 }
 cricket::FakeVoiceMediaReceiveChannel* VoiceMediaReceiveChannel(
-    rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver) {
+    rtc::scoped_refptr<RtpTransceiverInterface> transceiver) {
   return static_cast<cricket::FakeVoiceMediaReceiveChannel*>(
       ReceiveChannelInternal(transceiver));
 }
@@ -254,7 +254,7 @@
     return sdp_semantics_ == SdpSemantics::kUnifiedPlan;
   }
 
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   rtc::AutoSocketServerThread main_;
   const SdpSemantics sdp_semantics_;
@@ -1495,10 +1495,10 @@
 }
 
 template <typename C>
-bool CompareCodecs(const std::vector<webrtc::RtpCodecCapability>& capabilities,
+bool CompareCodecs(const std::vector<RtpCodecCapability>& capabilities,
                    const std::vector<C>& codecs) {
   bool capability_has_rtx =
-      absl::c_any_of(capabilities, [](const webrtc::RtpCodecCapability& codec) {
+      absl::c_any_of(capabilities, [](const RtpCodecCapability& codec) {
         return codec.name == cricket::kRtxCodecName;
       });
   bool codecs_has_rtx = absl::c_any_of(codecs, [](const C& codec) {
@@ -1510,16 +1510,16 @@
       codecs, std::back_inserter(codecs_no_rtx),
       [](const C& codec) { return codec.name != cricket::kRtxCodecName; });
 
-  std::vector<webrtc::RtpCodecCapability> capabilities_no_rtx;
+  std::vector<RtpCodecCapability> capabilities_no_rtx;
   absl::c_copy_if(capabilities, std::back_inserter(capabilities_no_rtx),
-                  [](const webrtc::RtpCodecCapability& codec) {
+                  [](const RtpCodecCapability& codec) {
                     return codec.name != cricket::kRtxCodecName;
                   });
 
   return capability_has_rtx == codecs_has_rtx &&
          absl::c_equal(
              capabilities_no_rtx, codecs_no_rtx,
-             [](const webrtc::RtpCodecCapability& capability, const C& codec) {
+             [](const RtpCodecCapability& capability, const C& codec) {
                return codec.MatchesRtpCodec(capability);
              });
 }
@@ -1538,9 +1538,9 @@
   auto capabilities = caller->pc_factory()->GetRtpSenderCapabilities(
       cricket::MediaType::MEDIA_TYPE_AUDIO);
 
-  std::vector<webrtc::RtpCodecCapability> codecs;
+  std::vector<RtpCodecCapability> codecs;
   absl::c_copy_if(capabilities.codecs, std::back_inserter(codecs),
-                  [](const webrtc::RtpCodecCapability& codec) {
+                  [](const RtpCodecCapability& codec) {
                     return codec.name.find("_only_") != std::string::npos;
                   });
 
@@ -1561,9 +1561,9 @@
   auto capabilities = caller->pc_factory()->GetRtpReceiverCapabilities(
       cricket::MediaType::MEDIA_TYPE_AUDIO);
 
-  std::vector<webrtc::RtpCodecCapability> codecs;
+  std::vector<RtpCodecCapability> codecs;
   absl::c_copy_if(capabilities.codecs, std::back_inserter(codecs),
-                  [](const webrtc::RtpCodecCapability& codec) {
+                  [](const RtpCodecCapability& codec) {
                     return codec.name.find("_only_") != std::string::npos;
                   });
 
@@ -1611,7 +1611,7 @@
   auto codecs_only_rtx_red_fec = codecs;
   auto it = std::remove_if(codecs_only_rtx_red_fec.begin(),
                            codecs_only_rtx_red_fec.end(),
-                           [](const webrtc::RtpCodecCapability& codec) {
+                           [](const RtpCodecCapability& codec) {
                              return !(codec.name == cricket::kRtxCodecName ||
                                       codec.name == cricket::kRedCodecName ||
                                       codec.name == cricket::kUlpfecCodecName);
@@ -1651,7 +1651,7 @@
       caller->pc_factory()
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_AUDIO)
           .codecs;
-  std::vector<webrtc::RtpCodecCapability> empty_codecs = {};
+  std::vector<RtpCodecCapability> empty_codecs = {};
 
   auto audio_transceiver = caller->pc()->GetTransceivers().front();
 
@@ -1706,7 +1706,7 @@
   auto codecs_only_rtx_red_fec = codecs;
   auto it = std::remove_if(codecs_only_rtx_red_fec.begin(),
                            codecs_only_rtx_red_fec.end(),
-                           [](const webrtc::RtpCodecCapability& codec) {
+                           [](const RtpCodecCapability& codec) {
                              return !(codec.name == cricket::kRtxCodecName ||
                                       codec.name == cricket::kRedCodecName ||
                                       codec.name == cricket::kUlpfecCodecName);
@@ -1747,7 +1747,7 @@
           ->GetRtpSenderCapabilities(cricket::MEDIA_TYPE_VIDEO)
           .codecs;
 
-  std::vector<webrtc::RtpCodecCapability> empty_codecs = {};
+  std::vector<RtpCodecCapability> empty_codecs = {};
 
   auto video_transceiver = caller->pc()->GetTransceivers().front();
 
@@ -1817,7 +1817,7 @@
   auto video_codecs_vpx_rtx = sender_video_codecs;
   auto it =
       std::remove_if(video_codecs_vpx_rtx.begin(), video_codecs_vpx_rtx.end(),
-                     [](const webrtc::RtpCodecCapability& codec) {
+                     [](const RtpCodecCapability& codec) {
                        return codec.name != cricket::kRtxCodecName &&
                               codec.name != cricket::kVp8CodecName &&
                               codec.name != cricket::kVp9CodecName;
@@ -1866,7 +1866,7 @@
 
   auto video_codecs_vpx = video_codecs;
   auto it = std::remove_if(video_codecs_vpx.begin(), video_codecs_vpx.end(),
-                           [](const webrtc::RtpCodecCapability& codec) {
+                           [](const RtpCodecCapability& codec) {
                              return codec.name != cricket::kVp8CodecName &&
                                     codec.name != cricket::kVp9CodecName;
                            });
@@ -1889,7 +1889,7 @@
   auto recv_transceiver = callee->pc()->GetTransceivers().front();
   auto video_codecs_vp8_rtx = video_codecs;
   it = std::remove_if(video_codecs_vp8_rtx.begin(), video_codecs_vp8_rtx.end(),
-                      [](const webrtc::RtpCodecCapability& codec) {
+                      [](const RtpCodecCapability& codec) {
                         bool r = codec.name != cricket::kVp8CodecName &&
                                  codec.name != cricket::kRtxCodecName;
                         return r;
@@ -1936,7 +1936,7 @@
 
   auto video_codecs_vpx = video_codecs;
   auto it = std::remove_if(video_codecs_vpx.begin(), video_codecs_vpx.end(),
-                           [](const webrtc::RtpCodecCapability& codec) {
+                           [](const RtpCodecCapability& codec) {
                              return codec.name != cricket::kVp8CodecName &&
                                     codec.name != cricket::kVp9CodecName;
                            });
diff --git a/pc/peer_connection_rampup_tests.cc b/pc/peer_connection_rampup_tests.cc
index 545a1d5..0fd3c27 100644
--- a/pc/peer_connection_rampup_tests.cc
+++ b/pc/peer_connection_rampup_tests.cc
@@ -201,7 +201,7 @@
     fake_network_managers_.emplace_back(fake_network_manager);
 
     auto observer = std::make_unique<MockPeerConnectionObserver>();
-    webrtc::PeerConnectionDependencies dependencies(observer.get());
+    PeerConnectionDependencies dependencies(observer.get());
     cricket::BasicPortAllocator* port_allocator =
         new cricket::BasicPortAllocator(fake_network_manager,
                                         firewall_socket_factory_.get());
diff --git a/pc/peer_connection_rtp_unittest.cc b/pc/peer_connection_rtp_unittest.cc
index b93e592..1a97a4b 100644
--- a/pc/peer_connection_rtp_unittest.cc
+++ b/pc/peer_connection_rtp_unittest.cc
@@ -75,13 +75,13 @@
 using ::testing::Values;
 
 template <typename MethodFunctor>
-class OnSuccessObserver : public webrtc::SetRemoteDescriptionObserverInterface {
+class OnSuccessObserver : public SetRemoteDescriptionObserverInterface {
  public:
   explicit OnSuccessObserver(MethodFunctor on_success)
       : on_success_(std::move(on_success)) {}
 
-  // webrtc::SetRemoteDescriptionObserverInterface implementation.
-  void OnSetRemoteDescriptionComplete(webrtc::RTCError error) override {
+  // SetRemoteDescriptionObserverInterface implementation.
+  void OnSetRemoteDescriptionComplete(RTCError error) override {
     RTC_CHECK(error.ok());
     on_success_();
   }
@@ -113,7 +113,7 @@
                                             Dav1dDecoderTemplateAdapter>>(),
             nullptr /* audio_mixer */,
             nullptr /* audio_processing */)) {
-    webrtc::metrics::Reset();
+    metrics::Reset();
   }
 
   std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
@@ -201,7 +201,7 @@
   }
 };
 
-// These tests cover `webrtc::PeerConnectionObserver` callbacks firing upon
+// These tests cover `PeerConnectionObserver` callbacks firing upon
 // setting the remote description.
 
 TEST_P(PeerConnectionRtpTest, AddTrackWithoutStreamFiresOnAddTrack) {
@@ -934,8 +934,8 @@
   auto caller = CreatePeerConnection();
   auto callee = CreatePeerConnection();
 
-  rtc::scoped_refptr<webrtc::MockSetSessionDescriptionObserver> observer =
-      rtc::make_ref_counted<webrtc::MockSetSessionDescriptionObserver>();
+  rtc::scoped_refptr<MockSetSessionDescriptionObserver> observer =
+      rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
 
   auto offer = caller->CreateOfferAndSetAsLocal();
   callee->pc()->SetRemoteDescription(observer.get(), offer.release());
diff --git a/pc/peer_connection_signaling_unittest.cc b/pc/peer_connection_signaling_unittest.cc
index 8ca59fc..aeba7ef 100644
--- a/pc/peer_connection_signaling_unittest.cc
+++ b/pc/peer_connection_signaling_unittest.cc
@@ -896,8 +896,8 @@
       "m=bogus 9 FOO 0 8\r\n"
       "c=IN IP4 0.0.0.0\r\n"
       "a=mid:bogusmid\r\n";
-  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
+  std::unique_ptr<SessionDescriptionInterface> remote_description =
+      CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
 
   EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description)));
 
@@ -977,8 +977,8 @@
       "a=ssrc-group:FEC-FR 1224551896 1953032773\r\n"
       "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"
       "a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n";
-  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
+  std::unique_ptr<SessionDescriptionInterface> remote_description =
+      CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
 
   EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description)));
 
@@ -1033,8 +1033,8 @@
       "a=ssrc-group:FEC-FR 1224551896 1953032773\r\n"
       "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"
       "a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n";
-  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
+  std::unique_ptr<SessionDescriptionInterface> remote_description =
+      CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
 
   EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description)));
 
@@ -1104,8 +1104,8 @@
       "a=rtcp-fb:102 nack\r\n"
       "a=rtcp-fb:102 nack pli\r\n"
       "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n";
-  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
+  std::unique_ptr<SessionDescriptionInterface> remote_description =
+      CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
 
   EXPECT_FALSE(caller->SetRemoteDescription(std::move(remote_description)));
 }
@@ -1339,8 +1339,8 @@
       "a=rtcp-fb:102 nack\r\n"
       "a=rtcp-fb:102 nack pli\r\n"
       "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n";
-  std::unique_ptr<webrtc::SessionDescriptionInterface> remote_description =
-      webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
+  std::unique_ptr<SessionDescriptionInterface> remote_description =
+      CreateSessionDescription(SdpType::kOffer, sdp, nullptr);
 
   EXPECT_TRUE(callee->SetRemoteDescription(std::move(remote_description)));
 
diff --git a/pc/peer_connection_simulcast_unittest.cc b/pc/peer_connection_simulcast_unittest.cc
index 6b6a96c..bffb5d9 100644
--- a/pc/peer_connection_simulcast_unittest.cc
+++ b/pc/peer_connection_simulcast_unittest.cc
@@ -220,7 +220,7 @@
     : public PeerConnectionSimulcastTests,
       public ::testing::WithParamInterface<int> {
  protected:
-  PeerConnectionSimulcastMetricsTests() { webrtc::metrics::Reset(); }
+  PeerConnectionSimulcastMetricsTests() { metrics::Reset(); }
 };
 #endif
 
diff --git a/pc/peer_connection_svc_integrationtest.cc b/pc/peer_connection_svc_integrationtest.cc
index 672f3ee..32ca451 100644
--- a/pc/peer_connection_svc_integrationtest.cc
+++ b/pc/peer_connection_svc_integrationtest.cc
@@ -37,14 +37,13 @@
       : PeerConnectionIntegrationBaseTest(SdpSemantics::kUnifiedPlan) {}
 
   RTCError SetCodecPreferences(
-      rtc::scoped_refptr<webrtc::RtpTransceiverInterface> transceiver,
+      rtc::scoped_refptr<RtpTransceiverInterface> transceiver,
       absl::string_view codec_name) {
-    webrtc::RtpCapabilities capabilities =
+    RtpCapabilities capabilities =
         caller()->pc_factory()->GetRtpSenderCapabilities(
             cricket::MEDIA_TYPE_VIDEO);
     std::vector<RtpCodecCapability> codecs;
-    for (const webrtc::RtpCodecCapability& codec_capability :
-         capabilities.codecs) {
+    for (const RtpCodecCapability& codec_capability : capabilities.codecs) {
       if (codec_capability.name == codec_name)
         codecs.push_back(codec_capability);
     }
@@ -55,8 +54,8 @@
 TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL1T1) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.scalability_mode = "L1T1";
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
@@ -67,8 +66,8 @@
 TEST_F(PeerConnectionSVCIntegrationTest, AddTransceiverAcceptsL3T3) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.scalability_mode = "L3T3";
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
@@ -80,33 +79,32 @@
        AddTransceiverRejectsUnknownScalabilityMode) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   encoding_parameters.scalability_mode = "FOOBAR";
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
   EXPECT_FALSE(transceiver_or_error.ok());
   EXPECT_EQ(transceiver_or_error.error().type(),
-            webrtc::RTCErrorType::UNSUPPORTED_OPERATION);
+            RTCErrorType::UNSUPPORTED_OPERATION);
 }
 
 TEST_F(PeerConnectionSVCIntegrationTest, SetParametersAcceptsL1T3WithVP8) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpCapabilities capabilities =
+  RtpCapabilities capabilities =
       caller()->pc_factory()->GetRtpSenderCapabilities(
           cricket::MEDIA_TYPE_VIDEO);
   std::vector<RtpCodecCapability> vp8_codec;
-  for (const webrtc::RtpCodecCapability& codec_capability :
-       capabilities.codecs) {
+  for (const RtpCodecCapability& codec_capability : capabilities.codecs) {
     if (codec_capability.name == cricket::kVp8CodecName)
       vp8_codec.push_back(codec_capability);
   }
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@@ -114,7 +112,7 @@
   auto transceiver = transceiver_or_error.MoveValue();
   EXPECT_TRUE(transceiver->SetCodecPreferences(vp8_codec).ok());
 
-  webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
+  RtpParameters parameters = transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "L1T3";
   auto result = transceiver->sender()->SetParameters(parameters);
@@ -125,8 +123,8 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@@ -134,12 +132,12 @@
   auto transceiver = transceiver_or_error.MoveValue();
   EXPECT_TRUE(SetCodecPreferences(transceiver, cricket::kVp8CodecName).ok());
 
-  webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
+  RtpParameters parameters = transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "L3T3";
   auto result = transceiver->sender()->SetParameters(parameters);
   EXPECT_FALSE(result.ok());
-  EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION);
+  EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
 }
 
 TEST_F(PeerConnectionSVCIntegrationTest,
@@ -147,8 +145,8 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@@ -159,7 +157,7 @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
-  webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
+  RtpParameters parameters = transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "L1T3";
   auto result = transceiver->sender()->SetParameters(parameters);
@@ -171,8 +169,8 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@@ -183,7 +181,7 @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
-  webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
+  RtpParameters parameters = transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "L3T3";
   auto result = transceiver->sender()->SetParameters(parameters);
@@ -195,8 +193,8 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@@ -207,12 +205,12 @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
-  webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
+  RtpParameters parameters = transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "L3T3";
   auto result = transceiver->sender()->SetParameters(parameters);
   EXPECT_FALSE(result.ok());
-  EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION);
+  EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
 }
 
 TEST_F(PeerConnectionSVCIntegrationTest,
@@ -220,8 +218,8 @@
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
@@ -232,27 +230,27 @@
   caller()->CreateAndSetAndSignalOffer();
   ASSERT_TRUE_WAIT(SignalingStateStable(), kDefaultTimeout);
 
-  webrtc::RtpParameters parameters = transceiver->sender()->GetParameters();
+  RtpParameters parameters = transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "FOOBAR";
   auto result = transceiver->sender()->SetParameters(parameters);
   EXPECT_FALSE(result.ok());
-  EXPECT_EQ(result.type(), webrtc::RTCErrorType::INVALID_MODIFICATION);
+  EXPECT_EQ(result.type(), RTCErrorType::INVALID_MODIFICATION);
 }
 
 TEST_F(PeerConnectionSVCIntegrationTest, FallbackToL1Tx) {
   ASSERT_TRUE(CreatePeerConnectionWrappers());
   ConnectFakeSignaling();
 
-  webrtc::RtpTransceiverInit init;
-  webrtc::RtpEncodingParameters encoding_parameters;
+  RtpTransceiverInit init;
+  RtpEncodingParameters encoding_parameters;
   init.send_encodings.push_back(encoding_parameters);
   auto transceiver_or_error =
       caller()->pc()->AddTransceiver(caller()->CreateLocalVideoTrack(), init);
   ASSERT_TRUE(transceiver_or_error.ok());
   auto caller_transceiver = transceiver_or_error.MoveValue();
 
-  webrtc::RtpCapabilities capabilities =
+  RtpCapabilities capabilities =
       caller()->pc_factory()->GetRtpSenderCapabilities(
           cricket::MEDIA_TYPE_VIDEO);
   std::vector<RtpCodecCapability> send_codecs = capabilities.codecs;
@@ -267,8 +265,7 @@
   caller_transceiver->SetCodecPreferences(send_codecs);
 
   // L3T3 should be supported by VP9
-  webrtc::RtpParameters parameters =
-      caller_transceiver->sender()->GetParameters();
+  RtpParameters parameters = caller_transceiver->sender()->GetParameters();
   ASSERT_EQ(parameters.encodings.size(), 1u);
   parameters.encodings[0].scalability_mode = "L3T3";
   auto result = caller_transceiver->sender()->SetParameters(parameters);
diff --git a/pc/peer_connection_wrapper.cc b/pc/peer_connection_wrapper.cc
index 44f4256..557d0c8 100644
--- a/pc/peer_connection_wrapper.cc
+++ b/pc/peer_connection_wrapper.cc
@@ -339,8 +339,7 @@
   return observer()->ice_connected_;
 }
 
-rtc::scoped_refptr<const webrtc::RTCStatsReport>
-PeerConnectionWrapper::GetStats() {
+rtc::scoped_refptr<const RTCStatsReport> PeerConnectionWrapper::GetStats() {
   auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
   pc()->GetStats(callback.get());
   EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc
index 0797ba2..2bac176 100644
--- a/pc/rtc_stats_collector.cc
+++ b/pc/rtc_stats_collector.cc
@@ -336,7 +336,7 @@
 
 std::map<std::string, double>
 QualityLimitationDurationToRTCQualityLimitationDuration(
-    std::map<webrtc::QualityLimitationReason, int64_t> durations_ms) {
+    std::map<QualityLimitationReason, int64_t> durations_ms) {
   std::map<std::string, double> result;
   // The internal duration is defined in milliseconds while the spec defines
   // the value in seconds:
@@ -513,7 +513,7 @@
 
 std::unique_ptr<RTCAudioPlayoutStats> CreateAudioPlayoutStats(
     const AudioDeviceModule::Stats& audio_device_stats,
-    webrtc::Timestamp timestamp) {
+    Timestamp timestamp) {
   auto stats = std::make_unique<RTCAudioPlayoutStats>(
       /*id=*/kAudioPlayoutSingletonId, timestamp);
   stats->synthesized_samples_duration =
diff --git a/pc/rtc_stats_collector.h b/pc/rtc_stats_collector.h
index e94d239..4c68e77 100644
--- a/pc/rtc_stats_collector.h
+++ b/pc/rtc_stats_collector.h
@@ -317,7 +317,7 @@
     uint32_t data_channels_closed;
     // Identifies channels that have been opened, whose internal id is stored in
     // the set until they have been fully closed.
-    webrtc::flat_set<int> opened_data_channels;
+    flat_set<int> opened_data_channels;
   };
   InternalRecord internal_record_;
 };
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index 37821ac..055be6f 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -263,9 +263,9 @@
   std::string kind() const override {
     return MediaStreamTrackInterface::kAudioKind;
   }
-  webrtc::AudioSourceInterface* GetSource() const override { return nullptr; }
-  void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
-  void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
+  AudioSourceInterface* GetSource() const override { return nullptr; }
+  void AddSink(AudioTrackSinkInterface* sink) override {}
+  void RemoveSink(AudioTrackSinkInterface* sink) override {}
   bool GetSignalLevel(int* level) override { return false; }
   rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
     return processor_;
@@ -2030,7 +2030,7 @@
   EXPECT_TRUE(report->Get(*expected_pair.transport_id));
 
   // Set bandwidth and "GetStats" again.
-  webrtc::Call::Stats call_stats;
+  Call::Stats call_stats;
   const int kSendBandwidth = 888;
   call_stats.send_bandwidth_bps = kSendBandwidth;
   const int kRecvBandwidth = 999;
@@ -2339,12 +2339,9 @@
   video_media_info.receivers[0].key_frames_decoded = 3;
   video_media_info.receivers[0].frames_dropped = 13;
   video_media_info.receivers[0].qp_sum = absl::nullopt;
-  video_media_info.receivers[0].total_decode_time =
-      webrtc::TimeDelta::Seconds(9);
-  video_media_info.receivers[0].total_processing_delay =
-      webrtc::TimeDelta::Millis(600);
-  video_media_info.receivers[0].total_assembly_time =
-      webrtc::TimeDelta::Millis(500);
+  video_media_info.receivers[0].total_decode_time = TimeDelta::Seconds(9);
+  video_media_info.receivers[0].total_processing_delay = TimeDelta::Millis(600);
+  video_media_info.receivers[0].total_assembly_time = TimeDelta::Millis(500);
   video_media_info.receivers[0].frames_assembled_from_multiple_packets = 23;
   video_media_info.receivers[0].total_inter_frame_delay = 0.123;
   video_media_info.receivers[0].total_squared_inter_frame_delay = 0.00456;
@@ -2617,12 +2614,12 @@
   video_media_info.senders[0].key_frames_encoded = 3;
   video_media_info.senders[0].total_encode_time_ms = 9000;
   video_media_info.senders[0].total_encoded_bytes_target = 1234;
-  video_media_info.senders[0].total_packet_send_delay =
-      webrtc::TimeDelta::Seconds(10);
+  video_media_info.senders[0].total_packet_send_delay = TimeDelta::Seconds(10);
   video_media_info.senders[0].quality_limitation_reason =
       QualityLimitationReason::kBandwidth;
-  video_media_info.senders[0].quality_limitation_durations_ms
-      [webrtc::QualityLimitationReason::kBandwidth] = 300;
+  video_media_info.senders[0]
+      .quality_limitation_durations_ms[QualityLimitationReason::kBandwidth] =
+      300;
   video_media_info.senders[0].quality_limitation_resolution_changes = 56u;
   video_media_info.senders[0].qp_sum = absl::nullopt;
   video_media_info.senders[0].content_type = VideoContentType::UNSPECIFIED;
diff --git a/pc/rtc_stats_traversal_unittest.cc b/pc/rtc_stats_traversal_unittest.cc
index 72ad255..8205ebe 100644
--- a/pc/rtc_stats_traversal_unittest.cc
+++ b/pc/rtc_stats_traversal_unittest.cc
@@ -47,7 +47,7 @@
     for (const RTCStats* start_node : start_nodes) {
       start_ids.push_back(start_node->id());
     }
-    result_ = webrtc::TakeReferencedStats(initial_report_, start_ids);
+    result_ = ::webrtc::TakeReferencedStats(initial_report_, start_ids);
   }
 
   void EXPECT_VISITED(const RTCStats* stats) {
diff --git a/pc/rtp_sender.cc b/pc/rtp_sender.cc
index cdae159..b0c32ef 100644
--- a/pc/rtp_sender.cc
+++ b/pc/rtp_sender.cc
@@ -115,13 +115,13 @@
     if (!signaling_thread_->IsCurrent()) {
       signaling_thread_->PostTask(
           [callback = std::move(callback_), error]() mutable {
-            webrtc::InvokeSetParametersCallback(callback, error);
+            InvokeSetParametersCallback(callback, error);
           });
       callback_ = nullptr;
       return;
     }
 
-    webrtc::InvokeSetParametersCallback(callback_, error);
+    InvokeSetParametersCallback(callback_, error);
     callback_ = nullptr;
   }
 
@@ -243,7 +243,7 @@
         "Attempted to set an unimplemented parameter of RtpParameters.");
     RTC_LOG(LS_ERROR) << error.message() << " ("
                       << ::webrtc::ToString(error.type()) << ")";
-    webrtc::InvokeSetParametersCallback(callback, error);
+    InvokeSetParametersCallback(callback, error);
     return;
   }
   if (!media_channel_ || !ssrc_) {
@@ -252,7 +252,7 @@
     if (result.ok()) {
       init_parameters_ = parameters;
     }
-    webrtc::InvokeSetParametersCallback(callback, result);
+    InvokeSetParametersCallback(callback, result);
     return;
   }
   auto task = [&, callback = std::move(callback),
@@ -268,13 +268,13 @@
     RTCError result = cricket::CheckRtpParametersInvalidModificationAndValues(
         old_parameters, rtp_parameters);
     if (!result.ok()) {
-      webrtc::InvokeSetParametersCallback(callback, result);
+      InvokeSetParametersCallback(callback, result);
       return;
     }
 
     result = CheckCodecParameters(rtp_parameters);
     if (!result.ok()) {
-      webrtc::InvokeSetParametersCallback(callback, result);
+      InvokeSetParametersCallback(callback, result);
       return;
     }
 
@@ -389,7 +389,7 @@
   TRACE_EVENT0("webrtc", "RtpSenderBase::SetParametersAsync");
   RTCError result = CheckSetParameters(parameters);
   if (!result.ok()) {
-    webrtc::InvokeSetParametersCallback(callback, result);
+    InvokeSetParametersCallback(callback, result);
     return;
   }
 
@@ -399,7 +399,7 @@
           signaling_thread_,
           [this, callback = std::move(callback)](RTCError error) mutable {
             last_transaction_id_.reset();
-            webrtc::InvokeSetParametersCallback(callback, error);
+            InvokeSetParametersCallback(callback, error);
           }),
       false);
 }
diff --git a/pc/rtp_sender.h b/pc/rtp_sender.h
index d29c376..26adceb 100644
--- a/pc/rtp_sender.h
+++ b/pc/rtp_sender.h
@@ -87,7 +87,7 @@
 
   // Additional checks that are specific to the current codec settings
   virtual RTCError CheckCodecParameters(const RtpParameters& parameters) {
-    return webrtc::RTCError::OK();
+    return RTCError::OK();
   }
 
   // Returns an ID that changes every time SetTrack() is called, but
diff --git a/pc/rtp_sender_receiver_unittest.cc b/pc/rtp_sender_receiver_unittest.cc
index 3092e53..4387aed 100644
--- a/pc/rtp_sender_receiver_unittest.cc
+++ b/pc/rtp_sender_receiver_unittest.cc
@@ -105,7 +105,7 @@
       : network_thread_(rtc::Thread::Current()),
         worker_thread_(rtc::Thread::Current()),
         video_bitrate_allocator_factory_(
-            webrtc::CreateBuiltinVideoBitrateAllocatorFactory()),
+            CreateBuiltinVideoBitrateAllocatorFactory()),
         // Create fake media engine/etc. so we can create channels to use to
         // test RtpSenders/RtpReceivers.
         media_engine_(std::make_unique<cricket::FakeMediaEngine>()),
@@ -119,16 +119,16 @@
     // Fake media channels are owned by the media engine.
     voice_media_send_channel_ = media_engine_->voice().CreateSendChannel(
         &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
-        webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
+        CryptoOptions(), AudioCodecPairId::Create());
     video_media_send_channel_ = media_engine_->video().CreateSendChannel(
         &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
-        webrtc::CryptoOptions(), video_bitrate_allocator_factory_.get());
+        CryptoOptions(), video_bitrate_allocator_factory_.get());
     voice_media_receive_channel_ = media_engine_->voice().CreateReceiveChannel(
         &fake_call_, cricket::MediaConfig(), cricket::AudioOptions(),
-        webrtc::CryptoOptions(), webrtc::AudioCodecPairId::Create());
+        CryptoOptions(), AudioCodecPairId::Create());
     video_media_receive_channel_ = media_engine_->video().CreateReceiveChannel(
         &fake_call_, cricket::MediaConfig(), cricket::VideoOptions(),
-        webrtc::CryptoOptions());
+        CryptoOptions());
 
     // Create streams for predefined SSRCs. Streams need to exist in order
     // for the senders and receievers to apply parameters to them.
@@ -162,8 +162,8 @@
     audio_track_ = nullptr;
   }
 
-  std::unique_ptr<webrtc::RtpTransportInternal> CreateDtlsSrtpTransport() {
-    auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>(
+  std::unique_ptr<RtpTransportInternal> CreateDtlsSrtpTransport() {
+    auto dtls_srtp_transport = std::make_unique<DtlsSrtpTransport>(
         /*rtcp_mux_required=*/true, field_trials_);
     dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport_.get(),
                                            /*rtcp_dtls_transport=*/nullptr);
@@ -515,12 +515,12 @@
   test::RunLoop run_loop_;
   rtc::Thread* const network_thread_;
   rtc::Thread* const worker_thread_;
-  webrtc::RtcEventLogNull event_log_;
+  RtcEventLogNull event_log_;
   // The `rtp_dtls_transport_` and `rtp_transport_` should be destroyed after
   // the `channel_manager`.
   std::unique_ptr<cricket::DtlsTransportInternal> rtp_dtls_transport_;
-  std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport_;
-  std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
+  std::unique_ptr<RtpTransportInternal> rtp_transport_;
+  std::unique_ptr<VideoBitrateAllocatorFactory>
       video_bitrate_allocator_factory_;
   std::unique_ptr<cricket::FakeMediaEngine> media_engine_;
   rtc::UniqueRandomIdGenerator ssrc_generator_;
@@ -540,7 +540,7 @@
   rtc::scoped_refptr<MediaStreamInterface> local_stream_;
   rtc::scoped_refptr<VideoTrackInterface> video_track_;
   rtc::scoped_refptr<AudioTrackInterface> audio_track_;
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
 };
 
 // Test that `voice_channel_` is updated when an audio track is associated
@@ -651,15 +651,13 @@
 TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) {
   CreateVideoRtpReceiver();
 
-  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state());
-  EXPECT_EQ(webrtc::MediaSourceInterface::kLive,
-            video_track_->GetSource()->state());
+  EXPECT_EQ(MediaStreamTrackInterface::kLive, video_track_->state());
+  EXPECT_EQ(MediaSourceInterface::kLive, video_track_->GetSource()->state());
 
   DestroyVideoRtpReceiver();
 
-  EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state());
-  EXPECT_EQ(webrtc::MediaSourceInterface::kEnded,
-            video_track_->GetSource()->state());
+  EXPECT_EQ(MediaStreamTrackInterface::kEnded, video_track_->state());
+  EXPECT_EQ(MediaSourceInterface::kEnded, video_track_->GetSource()->state());
   DestroyVideoRtpReceiver();
 }
 
@@ -888,9 +886,9 @@
 
   RtpParameters params = audio_rtp_sender_->GetParameters();
   EXPECT_EQ(1u, params.encodings.size());
-  absl::optional<webrtc::RTCError> result;
+  absl::optional<RTCError> result;
   audio_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
 
@@ -918,13 +916,13 @@
   audio_rtp_sender_ =
       AudioRtpSender::Create(worker_thread_, /*id=*/"", nullptr, nullptr);
 
-  absl::optional<webrtc::RTCError> result;
+  absl::optional<RTCError> result;
   RtpParameters params = audio_rtp_sender_->GetParameters();
   ASSERT_EQ(1u, params.encodings.size());
   params.encodings[0].max_bitrate_bps = 90000;
 
   audio_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
 
@@ -932,7 +930,7 @@
   EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000);
 
   audio_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
 
@@ -1016,13 +1014,13 @@
 
   RtpParameters params = audio_rtp_sender_->GetParameters();
   EXPECT_EQ(1u, params.encodings.size());
-  absl::optional<webrtc::RTCError> result;
+  absl::optional<RTCError> result;
   audio_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
   audio_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type());
 
@@ -1081,7 +1079,7 @@
   CreateAudioRtpSender();
 
   EXPECT_EQ(-1, voice_media_send_channel()->max_bps());
-  webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
+  RtpParameters params = audio_rtp_sender_->GetParameters();
   EXPECT_EQ(1U, params.encodings.size());
   EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
   params.encodings[0].max_bitrate_bps = 1000;
@@ -1106,10 +1104,9 @@
 TEST_F(RtpSenderReceiverTest, SetAudioBitratePriority) {
   CreateAudioRtpSender();
 
-  webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
+  RtpParameters params = audio_rtp_sender_->GetParameters();
   EXPECT_EQ(1U, params.encodings.size());
-  EXPECT_EQ(webrtc::kDefaultBitratePriority,
-            params.encodings[0].bitrate_priority);
+  EXPECT_EQ(kDefaultBitratePriority, params.encodings[0].bitrate_priority);
   double new_bitrate_priority = 2.0;
   params.encodings[0].bitrate_priority = new_bitrate_priority;
   EXPECT_TRUE(audio_rtp_sender_->SetParameters(params).ok());
@@ -1140,9 +1137,9 @@
 
   RtpParameters params = video_rtp_sender_->GetParameters();
   EXPECT_EQ(1u, params.encodings.size());
-  absl::optional<webrtc::RTCError> result;
+  absl::optional<RTCError> result;
   video_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
 
@@ -1170,19 +1167,19 @@
   video_rtp_sender_ =
       VideoRtpSender::Create(worker_thread_, /*id=*/"", nullptr);
 
-  absl::optional<webrtc::RTCError> result;
+  absl::optional<RTCError> result;
   RtpParameters params = video_rtp_sender_->GetParameters();
   ASSERT_EQ(1u, params.encodings.size());
   params.encodings[0].max_bitrate_bps = 90000;
   video_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
 
   params = video_rtp_sender_->GetParameters();
   EXPECT_EQ(params.encodings[0].max_bitrate_bps, 90000);
   video_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
 
@@ -1350,13 +1347,13 @@
 
   RtpParameters params = video_rtp_sender_->GetParameters();
   EXPECT_EQ(1u, params.encodings.size());
-  absl::optional<webrtc::RTCError> result;
+  absl::optional<RTCError> result;
   video_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_TRUE(result->ok());
   video_rtp_sender_->SetParametersAsync(
-      params, [&result](webrtc::RTCError error) { result = error; });
+      params, [&result](RTCError error) { result = error; });
   run_loop_.Flush();
   EXPECT_EQ(RTCErrorType::INVALID_STATE, result->type());
 
@@ -1453,7 +1450,7 @@
   CreateVideoRtpSender();
 
   RtpParameters params = video_rtp_sender_->GetParameters();
-  params.encodings[0].num_temporal_layers = webrtc::kMaxTemporalStreams + 1;
+  params.encodings[0].num_temporal_layers = kMaxTemporalStreams + 1;
   RTCError result = video_rtp_sender_->SetParameters(params);
   EXPECT_EQ(RTCErrorType::INVALID_RANGE, result.type());
 
@@ -1536,7 +1533,7 @@
   CreateVideoRtpSender();
 
   EXPECT_EQ(-1, video_media_send_channel()->max_bps());
-  webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
+  RtpParameters params = video_rtp_sender_->GetParameters();
   EXPECT_EQ(1U, params.encodings.size());
   EXPECT_FALSE(params.encodings[0].min_bitrate_bps);
   EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
@@ -1589,10 +1586,9 @@
 TEST_F(RtpSenderReceiverTest, SetVideoBitratePriority) {
   CreateVideoRtpSender();
 
-  webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
+  RtpParameters params = video_rtp_sender_->GetParameters();
   EXPECT_EQ(1U, params.encodings.size());
-  EXPECT_EQ(webrtc::kDefaultBitratePriority,
-            params.encodings[0].bitrate_priority);
+  EXPECT_EQ(kDefaultBitratePriority, params.encodings[0].bitrate_priority);
   double new_bitrate_priority = 2.0;
   params.encodings[0].bitrate_priority = new_bitrate_priority;
   EXPECT_TRUE(video_rtp_sender_->SetParameters(params).ok());
diff --git a/pc/rtp_transceiver.cc b/pc/rtp_transceiver.cc
index 815ec9d..ca626cc9 100644
--- a/pc/rtp_transceiver.cc
+++ b/pc/rtp_transceiver.cc
@@ -542,7 +542,7 @@
 
 RtpTransceiverDirection RtpTransceiver::direction() const {
   if (unified_plan_ && stopping())
-    return webrtc::RtpTransceiverDirection::kStopped;
+    return RtpTransceiverDirection::kStopped;
 
   return direction_;
 }
@@ -570,7 +570,7 @@
 absl::optional<RtpTransceiverDirection> RtpTransceiver::current_direction()
     const {
   if (unified_plan_ && stopped())
-    return webrtc::RtpTransceiverDirection::kStopped;
+    return RtpTransceiverDirection::kStopped;
 
   return current_direction_;
 }
@@ -604,7 +604,7 @@
   });
 
   stopping_ = true;
-  direction_ = webrtc::RtpTransceiverDirection::kInactive;
+  direction_ = RtpTransceiverDirection::kInactive;
 }
 
 RTCError RtpTransceiver::StopStandard() {
diff --git a/pc/rtp_transceiver.h b/pc/rtp_transceiver.h
index deda5d7..88febb9 100644
--- a/pc/rtp_transceiver.h
+++ b/pc/rtp_transceiver.h
@@ -358,20 +358,18 @@
 PROXY_CONSTMETHOD0(bool, stopped)
 PROXY_CONSTMETHOD0(bool, stopping)
 PROXY_CONSTMETHOD0(RtpTransceiverDirection, direction)
-PROXY_METHOD1(webrtc::RTCError, SetDirectionWithError, RtpTransceiverDirection)
+PROXY_METHOD1(RTCError, SetDirectionWithError, RtpTransceiverDirection)
 PROXY_CONSTMETHOD0(absl::optional<RtpTransceiverDirection>, current_direction)
 PROXY_CONSTMETHOD0(absl::optional<RtpTransceiverDirection>, fired_direction)
-PROXY_METHOD0(webrtc::RTCError, StopStandard)
+PROXY_METHOD0(RTCError, StopStandard)
 PROXY_METHOD0(void, StopInternal)
-PROXY_METHOD1(webrtc::RTCError,
-              SetCodecPreferences,
-              rtc::ArrayView<RtpCodecCapability>)
+PROXY_METHOD1(RTCError, SetCodecPreferences, rtc::ArrayView<RtpCodecCapability>)
 PROXY_CONSTMETHOD0(std::vector<RtpCodecCapability>, codec_preferences)
 PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
                    GetHeaderExtensionsToNegotiate)
 PROXY_CONSTMETHOD0(std::vector<RtpHeaderExtensionCapability>,
                    GetNegotiatedHeaderExtensions)
-PROXY_METHOD1(webrtc::RTCError,
+PROXY_METHOD1(RTCError,
               SetHeaderExtensionsToNegotiate,
               rtc::ArrayView<const RtpHeaderExtensionCapability>)
 END_PROXY_MAP(RtpTransceiver)
diff --git a/pc/rtp_transceiver_unittest.cc b/pc/rtp_transceiver_unittest.cc
index 63e06be..bd711f1 100644
--- a/pc/rtp_transceiver_unittest.cc
+++ b/pc/rtp_transceiver_unittest.cc
@@ -420,8 +420,8 @@
   EXPECT_CALL(*mock_channel, mid()).WillRepeatedly(ReturnRef(content_name));
   EXPECT_CALL(*mock_channel, SetRtpTransport(_)).WillRepeatedly(Return(true));
 
-  cricket::RtpHeaderExtensions extensions = {webrtc::RtpExtension("uri1", 1),
-                                             webrtc::RtpExtension("uri2", 2)};
+  cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
+                                             RtpExtension("uri2", 2)};
   cricket::AudioContentDescription description;
   description.set_rtp_header_extensions(extensions);
   transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@@ -449,8 +449,8 @@
   EXPECT_CALL(*sender_.get(), SetTransceiverAsStopped());
   EXPECT_CALL(*sender_.get(), Stop());
 
-  cricket::RtpHeaderExtensions extensions = {webrtc::RtpExtension("uri1", 1),
-                                             webrtc::RtpExtension("uri2", 2)};
+  cricket::RtpHeaderExtensions extensions = {RtpExtension("uri1", 1),
+                                             RtpExtension("uri2", 2)};
   cricket::AudioContentDescription description;
   description.set_rtp_header_extensions(extensions);
   transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
@@ -464,8 +464,7 @@
                                 RtpTransceiverDirection::kStopped),
                           Field(&RtpHeaderExtensionCapability::direction,
                                 RtpTransceiverDirection::kStopped)));
-  extensions = {webrtc::RtpExtension("uri3", 4),
-                webrtc::RtpExtension("uri5", 6)};
+  extensions = {RtpExtension("uri3", 4), RtpExtension("uri5", 6)};
   description.set_rtp_header_extensions(extensions);
   transceiver_->OnNegotiationUpdate(SdpType::kAnswer, &description);
 
diff --git a/pc/rtp_transport.cc b/pc/rtp_transport.cc
index 2ffb53f..7cf9fe0 100644
--- a/pc/rtp_transport.cc
+++ b/pc/rtp_transport.cc
@@ -186,10 +186,10 @@
 
 void RtpTransport::DemuxPacket(rtc::CopyOnWriteBuffer packet,
                                int64_t packet_time_us) {
-  webrtc::RtpPacketReceived parsed_packet(
-      &header_extension_map_, packet_time_us == -1
-                                  ? Timestamp::MinusInfinity()
-                                  : Timestamp::Micros(packet_time_us));
+  RtpPacketReceived parsed_packet(&header_extension_map_,
+                                  packet_time_us == -1
+                                      ? Timestamp::MinusInfinity()
+                                      : Timestamp::Micros(packet_time_us));
   if (!parsed_packet.Parse(std::move(packet))) {
     RTC_LOG(LS_ERROR)
         << "Failed to parse the incoming RTP packet before demuxing. Drop it.";
diff --git a/pc/rtp_transport_internal.h b/pc/rtp_transport_internal.h
index 4114fa9..483a1ce 100644
--- a/pc/rtp_transport_internal.h
+++ b/pc/rtp_transport_internal.h
@@ -72,7 +72,7 @@
   // Called whenever a RTP packet that can not be demuxed by the transport is
   // received.
   void SetUnDemuxableRtpPacketReceivedHandler(
-      absl::AnyInvocable<void(webrtc::RtpPacketReceived&)> callback) {
+      absl::AnyInvocable<void(RtpPacketReceived&)> callback) {
     callback_undemuxable_rtp_packet_received_ = std::move(callback);
   }
 
@@ -160,7 +160,7 @@
   CallbackList<bool> callback_list_ready_to_send_;
   CallbackList<rtc::CopyOnWriteBuffer*, int64_t>
       callback_list_rtcp_packet_received_;
-  absl::AnyInvocable<void(webrtc::RtpPacketReceived&)>
+  absl::AnyInvocable<void(RtpPacketReceived&)>
       callback_undemuxable_rtp_packet_received_ =
           [](RtpPacketReceived& packet) {};
   CallbackList<absl::optional<rtc::NetworkRoute>>
diff --git a/pc/sctp_transport.h b/pc/sctp_transport.h
index 35e7656..076dee5 100644
--- a/pc/sctp_transport.h
+++ b/pc/sctp_transport.h
@@ -61,7 +61,7 @@
   void Start(int local_port, int remote_port, int max_message_size);
 
   // TODO(https://bugs.webrtc.org/10629): Move functions that need
-  // internal() to be functions on the webrtc::SctpTransport interface,
+  // internal() to be functions on the SctpTransport interface,
   // and make the internal() function private.
   cricket::SctpTransportInternal* internal() {
     RTC_DCHECK_RUN_ON(owner_thread_);
diff --git a/pc/sdp_offer_answer.cc b/pc/sdp_offer_answer.cc
index 0261195..04d1aff 100644
--- a/pc/sdp_offer_answer.cc
+++ b/pc/sdp_offer_answer.cc
@@ -86,8 +86,7 @@
 
 namespace {
 
-typedef webrtc::PeerConnectionInterface::RTCOfferAnswerOptions
-    RTCOfferAnswerOptions;
+typedef PeerConnectionInterface::RTCOfferAnswerOptions RTCOfferAnswerOptions;
 
 // Error messages
 const char kInvalidSdp[] = "Invalid session description.";
@@ -834,8 +833,8 @@
 }
 
 // Check if we can send `new_stream` on a PeerConnection.
-bool CanAddLocalMediaStream(webrtc::StreamCollectionInterface* current_streams,
-                            webrtc::MediaStreamInterface* new_stream) {
+bool CanAddLocalMediaStream(StreamCollectionInterface* current_streams,
+                            MediaStreamInterface* new_stream) {
   if (!new_stream || !current_streams) {
     return false;
   }
@@ -847,7 +846,7 @@
   return true;
 }
 
-rtc::scoped_refptr<webrtc::DtlsTransport> LookupDtlsTransportByMid(
+rtc::scoped_refptr<DtlsTransport> LookupDtlsTransportByMid(
     rtc::Thread* network_thread,
     JsepTransportController* controller,
     const std::string& mid) {
diff --git a/pc/sdp_offer_answer.h b/pc/sdp_offer_answer.h
index 8aa7040..88ddfe0 100644
--- a/pc/sdp_offer_answer.h
+++ b/pc/sdp_offer_answer.h
@@ -674,8 +674,8 @@
   // or else the CreateBuiltinVideoBitrateAllocatorFactory() will be called.
   // Note that one can still choose to override this in a MediaEngine
   // if one wants too.
-  std::unique_ptr<webrtc::VideoBitrateAllocatorFactory>
-      video_bitrate_allocator_factory_ RTC_GUARDED_BY(signaling_thread());
+  std::unique_ptr<VideoBitrateAllocatorFactory> video_bitrate_allocator_factory_
+      RTC_GUARDED_BY(signaling_thread());
 
   // Whether we are the initial offerer on the association. This
   // determines the SSL role.
diff --git a/pc/sdp_offer_answer_unittest.cc b/pc/sdp_offer_answer_unittest.cc
index 94ceff1..9a44360 100644
--- a/pc/sdp_offer_answer_unittest.cc
+++ b/pc/sdp_offer_answer_unittest.cc
@@ -88,7 +88,7 @@
                                             Dav1dDecoderTemplateAdapter>>(),
             nullptr /* audio_mixer */,
             nullptr /* audio_processing */)) {
-    webrtc::metrics::Reset();
+    metrics::Reset();
   }
 
   std::unique_ptr<PeerConnectionWrapper> CreatePeerConnection() {
@@ -168,8 +168,8 @@
   // There is no error yet but the metrics counter will increase.
   EXPECT_TRUE(error.ok());
   EXPECT_METRIC_EQ(
-      1, webrtc::metrics::NumEvents(
-             "WebRTC.PeerConnection.ValidBundledPayloadTypes", false));
+      1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
+                            false));
 
   // Tolerate codec collisions in rejected m-lines.
   pc = CreatePeerConnection();
@@ -178,9 +178,9 @@
       absl::StrReplaceAll(sdp, {{"m=video 9 ", "m=video 0 "}}));
   pc->SetRemoteDescription(std::move(rejected_offer), &error);
   EXPECT_TRUE(error.ok());
-  EXPECT_METRIC_EQ(1,
-                   webrtc::metrics::NumEvents(
-                       "WebRTC.PeerConnection.ValidBundledPayloadTypes", true));
+  EXPECT_METRIC_EQ(
+      1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
+                            true));
 }
 
 TEST_F(SdpOfferAnswerTest, BundleRejectsCodecCollisionsVideoFmtp) {
@@ -221,8 +221,8 @@
   pc->SetRemoteDescription(std::move(desc), &error);
   EXPECT_TRUE(error.ok());
   EXPECT_METRIC_EQ(
-      1, webrtc::metrics::NumEvents(
-             "WebRTC.PeerConnection.ValidBundledPayloadTypes", false));
+      1, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
+                            false));
 }
 
 TEST_F(SdpOfferAnswerTest, BundleCodecCollisionInDifferentBundlesAllowed) {
@@ -264,8 +264,8 @@
   pc->SetRemoteDescription(std::move(desc), &error);
   EXPECT_TRUE(error.ok());
   EXPECT_METRIC_EQ(
-      0, webrtc::metrics::NumEvents(
-             "WebRTC.PeerConnection.ValidBundledPayloadTypes", false));
+      0, metrics::NumEvents("WebRTC.PeerConnection.ValidBundledPayloadTypes",
+                            false));
 }
 
 TEST_F(SdpOfferAnswerTest, BundleMeasuresHeaderExtensionIdCollision) {
diff --git a/pc/slow_peer_connection_integration_test.cc b/pc/slow_peer_connection_integration_test.cc
index fd9d341..4e26283 100644
--- a/pc/slow_peer_connection_integration_test.cc
+++ b/pc/slow_peer_connection_integration_test.cc
@@ -67,7 +67,7 @@
     // Some things use a time of "0" as a special value, so we need to start out
     // the fake clock at a nonzero time.
     // TODO(deadbeef): Fix this.
-    AdvanceTime(webrtc::TimeDelta::Seconds(1000));
+    AdvanceTime(TimeDelta::Seconds(1000));
   }
 
   // Explicit handle.
@@ -170,20 +170,20 @@
   CreateTurnServer(turn_server_internal_address, turn_server_external_address,
                    cricket::PROTO_TLS, "88.88.88.0");
 
-  webrtc::PeerConnectionInterface::IceServer ice_server;
+  PeerConnectionInterface::IceServer ice_server;
   ice_server.urls.push_back("turns:88.88.88.0:3478?transport=tcp");
   ice_server.username = "test";
   ice_server.password = "test";
 
   PeerConnectionInterface::RTCConfiguration client_1_config;
   client_1_config.servers.push_back(ice_server);
-  client_1_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_1_config.type = PeerConnectionInterface::kRelay;
 
   PeerConnectionInterface::RTCConfiguration client_2_config;
   client_2_config.servers.push_back(ice_server);
   // Setting the type to kRelay forces the connection to go through a TURN
   // server.
-  client_2_config.type = webrtc::PeerConnectionInterface::kRelay;
+  client_2_config.type = PeerConnectionInterface::kRelay;
 
   // Get a copy to the pointer so we can verify calls later.
   rtc::TestCertificateVerifier* client_1_cert_verifier =
@@ -194,10 +194,10 @@
   client_2_cert_verifier->verify_certificate_ = false;
 
   // Create the dependencies with the test certificate verifier.
-  webrtc::PeerConnectionDependencies client_1_deps(nullptr);
+  PeerConnectionDependencies client_1_deps(nullptr);
   client_1_deps.tls_cert_verifier =
       std::unique_ptr<rtc::TestCertificateVerifier>(client_1_cert_verifier);
-  webrtc::PeerConnectionDependencies client_2_deps(nullptr);
+  PeerConnectionDependencies client_2_deps(nullptr);
   client_2_deps.tls_cert_verifier =
       std::unique_ptr<rtc::TestCertificateVerifier>(client_2_cert_verifier);
 
diff --git a/pc/srtp_transport_unittest.cc b/pc/srtp_transport_unittest.cc
index fead5d6..de4ff03 100644
--- a/pc/srtp_transport_unittest.cc
+++ b/pc/srtp_transport_unittest.cc
@@ -342,7 +342,7 @@
   TransportObserver rtp_sink2_;
 
   int sequence_number_ = 0;
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
 };
 
 class SrtpTransportTestWithExternalAuth
diff --git a/pc/test/android_test_initializer.cc b/pc/test/android_test_initializer.cc
index 963544c..88b4587 100644
--- a/pc/test/android_test_initializer.cc
+++ b/pc/test/android_test_initializer.cc
@@ -39,7 +39,7 @@
 
   RTC_CHECK(rtc::InitializeSSL()) << "Failed to InitializeSSL()";
 
-  webrtc::JVM::Initialize(jvm);
+  JVM::Initialize(jvm);
 }
 
 }  // anonymous namespace
diff --git a/pc/test/fake_peer_connection_base.h b/pc/test/fake_peer_connection_base.h
index a1c8dca..1615088 100644
--- a/pc/test/fake_peer_connection_base.h
+++ b/pc/test/fake_peer_connection_base.h
@@ -363,7 +363,7 @@
   const FieldTrialsView& trials() const override { return field_trials_; }
 
  protected:
-  webrtc::test::ScopedKeyValueConfig field_trials_;
+  test::ScopedKeyValueConfig field_trials_;
 };
 
 }  // namespace webrtc
diff --git a/pc/test/fake_peer_connection_for_stats.h b/pc/test/fake_peer_connection_for_stats.h
index a65e6d5..33a5361 100644
--- a/pc/test/fake_peer_connection_for_stats.h
+++ b/pc/test/fake_peer_connection_for_stats.h
@@ -150,7 +150,7 @@
           receive_channel,
       const std::string& content_name,
       bool srtp_required,
-      webrtc::CryptoOptions crypto_options,
+      CryptoOptions crypto_options,
       rtc::UniqueRandomIdGenerator* ssrc_generator,
       std::string transport_name)
       : VoiceChannel(worker_thread,
@@ -183,7 +183,7 @@
           receive_channel,
       const std::string& content_name,
       bool srtp_required,
-      webrtc::CryptoOptions crypto_options,
+      CryptoOptions crypto_options,
       rtc::UniqueRandomIdGenerator* ssrc_generator,
       std::string transport_name)
       : VideoChannel(worker_thread,
@@ -298,7 +298,7 @@
         worker_thread_, network_thread_, signaling_thread_,
         std::move(voice_media_send_channel),
         std::move(voice_media_receive_channel), mid, kDefaultSrtpRequired,
-        webrtc::CryptoOptions(), context_->ssrc_generator(), transport_name);
+        CryptoOptions(), context_->ssrc_generator(), transport_name);
     auto transceiver =
         GetOrCreateFirstTransceiverOfType(cricket::MEDIA_TYPE_AUDIO)
             ->internal();
@@ -332,7 +332,7 @@
         worker_thread_, network_thread_, signaling_thread_,
         std::move(video_media_send_channel),
         std::move(video_media_receive_channel), mid, kDefaultSrtpRequired,
-        webrtc::CryptoOptions(), context_->ssrc_generator(), transport_name);
+        CryptoOptions(), context_->ssrc_generator(), transport_name);
     auto transceiver =
         GetOrCreateFirstTransceiverOfType(cricket::MEDIA_TYPE_VIDEO)
             ->internal();
diff --git a/pc/test/fake_periodic_video_source.h b/pc/test/fake_periodic_video_source.h
index 452a8f6..65652bd 100644
--- a/pc/test/fake_periodic_video_source.h
+++ b/pc/test/fake_periodic_video_source.h
@@ -65,12 +65,12 @@
     return wants_;
   }
 
-  void RemoveSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink) override {
+  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {
     RTC_DCHECK(thread_checker_.IsCurrent());
     broadcaster_.RemoveSink(sink);
   }
 
-  void AddOrUpdateSink(rtc::VideoSinkInterface<webrtc::VideoFrame>* sink,
+  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                        const rtc::VideoSinkWants& wants) override {
     RTC_DCHECK(thread_checker_.IsCurrent());
     {
diff --git a/pc/test/integration_test_helpers.cc b/pc/test/integration_test_helpers.cc
index ede159d..64d8deb 100644
--- a/pc/test/integration_test_helpers.cc
+++ b/pc/test/integration_test_helpers.cc
@@ -46,7 +46,7 @@
 
 int FindFirstMediaStatsIndexByKind(
     const std::string& kind,
-    const std::vector<const webrtc::RTCInboundRtpStreamStats*>& inbound_rtps) {
+    const std::vector<const RTCInboundRtpStreamStats*>& inbound_rtps) {
   for (size_t i = 0; i < inbound_rtps.size(); i++) {
     if (*inbound_rtps[i]->kind == kind) {
       return i;
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index c61712c..1ba3326 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -177,14 +177,14 @@
 
 int FindFirstMediaStatsIndexByKind(
     const std::string& kind,
-    const std::vector<const webrtc::RTCInboundRtpStreamStats*>& inbound_rtps);
+    const std::vector<const RTCInboundRtpStreamStats*>& inbound_rtps);
 
-class TaskQueueMetronome : public webrtc::Metronome {
+class TaskQueueMetronome : public Metronome {
  public:
   explicit TaskQueueMetronome(TimeDelta tick_period);
   ~TaskQueueMetronome() override;
 
-  // webrtc::Metronome implementation.
+  // Metronome implementation.
   void RequestCallOnNextTick(absl::AnyInvocable<void() &&> callback) override;
   TimeDelta TickPeriod() const override;
 
@@ -207,7 +207,7 @@
   virtual ~SignalingMessageReceiver() {}
 };
 
-class MockRtpReceiverObserver : public webrtc::RtpReceiverObserverInterface {
+class MockRtpReceiverObserver : public RtpReceiverObserverInterface {
  public:
   explicit MockRtpReceiverObserver(cricket::MediaType media_type)
       : expected_media_type_(media_type) {}
@@ -234,14 +234,14 @@
 // advertise support of any codecs.
 // TODO(steveanton): See how this could become a subclass of
 // PeerConnectionWrapper defined in peerconnectionwrapper.h.
-class PeerConnectionIntegrationWrapper : public webrtc::PeerConnectionObserver,
+class PeerConnectionIntegrationWrapper : public PeerConnectionObserver,
                                          public SignalingMessageReceiver {
  public:
-  webrtc::PeerConnectionFactoryInterface* pc_factory() const {
+  PeerConnectionFactoryInterface* pc_factory() const {
     return peer_connection_factory_.get();
   }
 
-  webrtc::PeerConnectionInterface* pc() const { return peer_connection_.get(); }
+  PeerConnectionInterface* pc() const { return peer_connection_.get(); }
 
   // If a signaling message receiver is set (via ConnectFakeSignaling), this
   // will set the whole offer/answer exchange in motion. Just need to wait for
@@ -339,11 +339,11 @@
     return AddTrack(CreateLocalVideoTrack());
   }
 
-  rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack() {
+  rtc::scoped_refptr<AudioTrackInterface> CreateLocalAudioTrack() {
     cricket::AudioOptions options;
     // Disable highpass filter so that we can get all the test audio frames.
     options.highpass_filter = false;
-    rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
+    rtc::scoped_refptr<AudioSourceInterface> source =
         peer_connection_factory_->CreateAudioSource(options);
     // TODO(perkj): Test audio source when it is implemented. Currently audio
     // always use the default input.
@@ -351,21 +351,20 @@
                                                       source.get());
   }
 
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack() {
-    webrtc::FakePeriodicVideoSource::Config config;
+  rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrack() {
+    FakePeriodicVideoSource::Config config;
     config.timestamp_offset_ms = rtc::TimeMillis();
     return CreateLocalVideoTrackInternal(config);
   }
 
-  rtc::scoped_refptr<webrtc::VideoTrackInterface>
-  CreateLocalVideoTrackWithConfig(
-      webrtc::FakePeriodicVideoSource::Config config) {
+  rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithConfig(
+      FakePeriodicVideoSource::Config config) {
     return CreateLocalVideoTrackInternal(config);
   }
 
-  rtc::scoped_refptr<webrtc::VideoTrackInterface>
-  CreateLocalVideoTrackWithRotation(webrtc::VideoRotation rotation) {
-    webrtc::FakePeriodicVideoSource::Config config;
+  rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackWithRotation(
+      VideoRotation rotation) {
+    FakePeriodicVideoSource::Config config;
     config.rotation = rotation;
     config.timestamp_offset_ms = rtc::TimeMillis();
     return CreateLocalVideoTrackInternal(config);
@@ -409,22 +408,22 @@
   }
 
   bool SignalingStateStable() {
-    return pc()->signaling_state() == webrtc::PeerConnectionInterface::kStable;
+    return pc()->signaling_state() == PeerConnectionInterface::kStable;
   }
 
   bool IceGatheringStateComplete() {
     return pc()->ice_gathering_state() ==
-           webrtc::PeerConnectionInterface::kIceGatheringComplete;
+           PeerConnectionInterface::kIceGatheringComplete;
   }
 
   void CreateDataChannel() { CreateDataChannel(nullptr); }
 
-  void CreateDataChannel(const webrtc::DataChannelInit* init) {
+  void CreateDataChannel(const DataChannelInit* init) {
     CreateDataChannel(kDataChannelLabel, init);
   }
 
   void CreateDataChannel(const std::string& label,
-                         const webrtc::DataChannelInit* init) {
+                         const DataChannelInit* init) {
     auto data_channel_or_error = pc()->CreateDataChannelOrError(label, init);
     ASSERT_TRUE(data_channel_or_error.ok());
     data_channels_.push_back(data_channel_or_error.MoveValue());
@@ -482,7 +481,7 @@
   // Returns a MockStatsObserver in a state after stats gathering finished,
   // which can be used to access the gathered stats.
   rtc::scoped_refptr<MockStatsObserver> OldGetStatsForTrack(
-      webrtc::MediaStreamTrackInterface* track) {
+      MediaStreamTrackInterface* track) {
     auto observer = rtc::make_ref_counted<MockStatsObserver>();
     EXPECT_TRUE(peer_connection_->GetStats(
         observer.get(), nullptr,
@@ -498,9 +497,8 @@
 
   // Synchronously gets stats and returns them. If it times out, fails the test
   // and returns null.
-  rtc::scoped_refptr<const webrtc::RTCStatsReport> NewGetStats() {
-    auto callback =
-        rtc::make_ref_counted<webrtc::MockRTCStatsCollectorCallback>();
+  rtc::scoped_refptr<const RTCStatsReport> NewGetStats() {
+    auto callback = rtc::make_ref_counted<MockRTCStatsCollectorCallback>();
     peer_connection_->GetStats(callback.get());
     EXPECT_TRUE_WAIT(callback->called(), kDefaultTimeout);
     return callback->report();
@@ -527,10 +525,10 @@
     return static_cast<double>(rendered_width()) / rendered_height();
   }
 
-  webrtc::VideoRotation rendered_rotation() {
+  VideoRotation rendered_rotation() {
     EXPECT_FALSE(fake_video_renderers_.empty());
     return fake_video_renderers_.empty()
-               ? webrtc::kVideoRotation_0
+               ? kVideoRotation_0
                : fake_video_renderers_.begin()->second->rotation();
   }
 
@@ -573,20 +571,20 @@
     return pc()->local_streams().get();
   }
 
-  webrtc::PeerConnectionInterface::SignalingState signaling_state() {
+  PeerConnectionInterface::SignalingState signaling_state() {
     return pc()->signaling_state();
   }
 
-  webrtc::PeerConnectionInterface::IceConnectionState ice_connection_state() {
+  PeerConnectionInterface::IceConnectionState ice_connection_state() {
     return pc()->ice_connection_state();
   }
 
-  webrtc::PeerConnectionInterface::IceConnectionState
+  PeerConnectionInterface::IceConnectionState
   standardized_ice_connection_state() {
     return pc()->standardized_ice_connection_state();
   }
 
-  webrtc::PeerConnectionInterface::IceGatheringState ice_gathering_state() {
+  PeerConnectionInterface::IceGatheringState ice_gathering_state() {
     return pc()->ice_gathering_state();
   }
 
@@ -615,7 +613,7 @@
   }
   cricket::PortAllocator* port_allocator() const { return port_allocator_; }
 
-  webrtc::FakeRtcEventLogFactory* event_log_factory() const {
+  FakeRtcEventLogFactory* event_log_factory() const {
     return event_log_factory_;
   }
 
@@ -628,8 +626,7 @@
 
   // Sets the mDNS responder for the owned fake network manager and keeps a
   // reference to the responder.
-  void SetMdnsResponder(
-      std::unique_ptr<webrtc::FakeMdnsResponder> mdns_responder) {
+  void SetMdnsResponder(std::unique_ptr<FakeMdnsResponder> mdns_responder) {
     RTC_DCHECK(mdns_responder != nullptr);
     mdns_responder_ = mdns_responder.get();
     network_manager()->set_mdns_responder(std::move(mdns_responder));
@@ -644,7 +641,7 @@
   }
   bool Rollback() {
     return SetRemoteDescription(
-        webrtc::CreateSessionDescription(SdpType::kRollback, ""));
+        CreateSessionDescription(SdpType::kRollback, ""));
   }
 
   // Functions for querying stats.
@@ -652,7 +649,7 @@
     // Get the baseline numbers for audio_packets and audio_delay.
     auto received_stats = NewGetStats();
     auto rtp_stats =
-        received_stats->GetStatsOfType<webrtc::RTCInboundRtpStreamStats>()[0];
+        received_stats->GetStatsOfType<RTCInboundRtpStreamStats>()[0];
     ASSERT_TRUE(rtp_stats->relative_packet_arrival_delay.is_defined());
     ASSERT_TRUE(rtp_stats->packets_received.is_defined());
     rtp_stats_id_ = rtp_stats->id();
@@ -664,8 +661,7 @@
 
   void UpdateDelayStats(std::string tag, int desc_size) {
     auto report = NewGetStats();
-    auto rtp_stats =
-        report->GetAs<webrtc::RTCInboundRtpStreamStats>(rtp_stats_id_);
+    auto rtp_stats = report->GetAs<RTCInboundRtpStreamStats>(rtp_stats_id_);
     ASSERT_TRUE(rtp_stats);
     auto delta_packets = *rtp_stats->packets_received - audio_packets_stat_;
     auto delta_rpad =
@@ -744,11 +740,11 @@
 
   bool Init(const PeerConnectionFactory::Options* options,
             const PeerConnectionInterface::RTCConfiguration* config,
-            webrtc::PeerConnectionDependencies dependencies,
+            PeerConnectionDependencies dependencies,
             rtc::SocketServer* socket_server,
             rtc::Thread* network_thread,
             rtc::Thread* worker_thread,
-            std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
+            std::unique_ptr<FakeRtcEventLogFactory> event_log_factory,
             bool reset_encoder_factory,
             bool reset_decoder_factory,
             bool create_media_engine) {
@@ -771,12 +767,12 @@
     }
     rtc::Thread* const signaling_thread = rtc::Thread::Current();
 
-    webrtc::PeerConnectionFactoryDependencies pc_factory_dependencies;
+    PeerConnectionFactoryDependencies pc_factory_dependencies;
     pc_factory_dependencies.network_thread = network_thread;
     pc_factory_dependencies.worker_thread = worker_thread;
     pc_factory_dependencies.signaling_thread = signaling_thread;
     pc_factory_dependencies.task_queue_factory =
-        webrtc::CreateDefaultTaskQueueFactory();
+        CreateDefaultTaskQueueFactory();
     pc_factory_dependencies.trials = std::make_unique<FieldTrialBasedConfig>();
     pc_factory_dependencies.metronome =
         std::make_unique<TaskQueueMetronome>(TimeDelta::Millis(8));
@@ -805,11 +801,11 @@
       pc_factory_dependencies.event_log_factory = std::move(event_log_factory);
     } else {
       pc_factory_dependencies.event_log_factory =
-          std::make_unique<webrtc::RtcEventLogFactory>(
+          std::make_unique<RtcEventLogFactory>(
               pc_factory_dependencies.task_queue_factory.get());
     }
-    peer_connection_factory_ = webrtc::CreateModularPeerConnectionFactory(
-        std::move(pc_factory_dependencies));
+    peer_connection_factory_ =
+        CreateModularPeerConnectionFactory(std::move(pc_factory_dependencies));
 
     if (!peer_connection_factory_) {
       return false;
@@ -826,9 +822,9 @@
     return peer_connection_.get() != nullptr;
   }
 
-  rtc::scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
+  rtc::scoped_refptr<PeerConnectionInterface> CreatePeerConnection(
       const PeerConnectionInterface::RTCConfiguration* config,
-      webrtc::PeerConnectionDependencies dependencies) {
+      PeerConnectionDependencies dependencies) {
     PeerConnectionInterface::RTCConfiguration modified_config;
     modified_config.sdp_semantics = sdp_semantics_;
     // If `config` is null, this will result in a default configuration being
@@ -861,21 +857,20 @@
     signal_ice_candidates_ = signal;
   }
 
-  rtc::scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrackInternal(
-      webrtc::FakePeriodicVideoSource::Config config) {
+  rtc::scoped_refptr<VideoTrackInterface> CreateLocalVideoTrackInternal(
+      FakePeriodicVideoSource::Config config) {
     // Set max frame rate to 10fps to reduce the risk of test flakiness.
     // TODO(deadbeef): Do something more robust.
     config.frame_interval_ms = 100;
 
     video_track_sources_.emplace_back(
-        rtc::make_ref_counted<webrtc::FakePeriodicVideoTrackSource>(
+        rtc::make_ref_counted<FakePeriodicVideoTrackSource>(
             config, false /* remote */));
-    rtc::scoped_refptr<webrtc::VideoTrackInterface> track =
+    rtc::scoped_refptr<VideoTrackInterface> track =
         peer_connection_factory_->CreateVideoTrack(video_track_sources_.back(),
                                                    rtc::CreateRandomUuid());
     if (!local_video_renderer_) {
-      local_video_renderer_.reset(
-          new webrtc::FakeVideoTrackRenderer(track.get()));
+      local_video_renderer_.reset(new FakeVideoTrackRenderer(track.get()));
     }
     return track;
   }
@@ -883,7 +878,7 @@
   void HandleIncomingOffer(const std::string& msg) {
     RTC_LOG(LS_INFO) << debug_name_ << ": HandleIncomingOffer";
     std::unique_ptr<SessionDescriptionInterface> desc =
-        webrtc::CreateSessionDescription(SdpType::kOffer, msg);
+        CreateSessionDescription(SdpType::kOffer, msg);
     if (received_sdp_munger_) {
       received_sdp_munger_(desc->description());
     }
@@ -903,7 +898,7 @@
   void HandleIncomingAnswer(const std::string& msg) {
     RTC_LOG(LS_INFO) << debug_name_ << ": HandleIncomingAnswer";
     std::unique_ptr<SessionDescriptionInterface> desc =
-        webrtc::CreateSessionDescription(SdpType::kAnswer, msg);
+        CreateSessionDescription(SdpType::kAnswer, msg);
     if (received_sdp_munger_) {
       received_sdp_munger_(desc->description());
     }
@@ -1054,7 +1049,7 @@
                          const std::string& msg) override {
     RTC_LOG(LS_INFO) << debug_name_ << ": ReceiveIceMessage";
     absl::optional<RTCError> result;
-    pc()->AddIceCandidate(absl::WrapUnique(webrtc::CreateIceCandidate(
+    pc()->AddIceCandidate(absl::WrapUnique(CreateIceCandidate(
                               sdp_mid, sdp_mline_index, msg, nullptr)),
                           [&result](RTCError r) { result = r; });
     EXPECT_TRUE_WAIT(result.has_value(), kDefaultTimeout);
@@ -1063,7 +1058,7 @@
 
   // PeerConnectionObserver callbacks.
   void OnSignalingChange(
-      webrtc::PeerConnectionInterface::SignalingState new_state) override {
+      PeerConnectionInterface::SignalingState new_state) override {
     EXPECT_EQ(pc()->signaling_state(), new_state);
     peer_connection_signaling_state_history_.push_back(new_state);
   }
@@ -1092,21 +1087,21 @@
   }
   void OnRenegotiationNeeded() override {}
   void OnIceConnectionChange(
-      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
+      PeerConnectionInterface::IceConnectionState new_state) override {
     EXPECT_EQ(pc()->ice_connection_state(), new_state);
     ice_connection_state_history_.push_back(new_state);
   }
   void OnStandardizedIceConnectionChange(
-      webrtc::PeerConnectionInterface::IceConnectionState new_state) override {
+      PeerConnectionInterface::IceConnectionState new_state) override {
     standardized_ice_connection_state_history_.push_back(new_state);
   }
   void OnConnectionChange(
-      webrtc::PeerConnectionInterface::PeerConnectionState new_state) override {
+      PeerConnectionInterface::PeerConnectionState new_state) override {
     peer_connection_state_history_.push_back(new_state);
   }
 
   void OnIceGatheringChange(
-      webrtc::PeerConnectionInterface::IceGatheringState new_state) override {
+      PeerConnectionInterface::IceGatheringState new_state) override {
     EXPECT_EQ(pc()->ice_gathering_state(), new_state);
     ice_gathering_state_history_.push_back(new_state);
   }
@@ -1116,7 +1111,7 @@
     ice_candidate_pair_change_history_.push_back(event);
   }
 
-  void OnIceCandidate(const webrtc::IceCandidateInterface* candidate) override {
+  void OnIceCandidate(const IceCandidateInterface* candidate) override {
     RTC_LOG(LS_INFO) << debug_name_ << ": OnIceCandidate";
 
     if (remote_async_dns_resolver_) {
@@ -1172,20 +1167,19 @@
   std::unique_ptr<rtc::FakeNetworkManager> fake_network_manager_;
   std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
   // Reference to the mDNS responder owned by `fake_network_manager_` after set.
-  webrtc::FakeMdnsResponder* mdns_responder_ = nullptr;
+  FakeMdnsResponder* mdns_responder_ = nullptr;
 
-  rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
-  rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>
-      peer_connection_factory_;
+  rtc::scoped_refptr<PeerConnectionInterface> peer_connection_;
+  rtc::scoped_refptr<PeerConnectionFactoryInterface> peer_connection_factory_;
 
   cricket::PortAllocator* port_allocator_;
   // Needed to keep track of number of frames sent.
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
   // Needed to keep track of number of frames received.
-  std::map<std::string, std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
+  std::map<std::string, std::unique_ptr<FakeVideoTrackRenderer>>
       fake_video_renderers_;
   // Needed to ensure frames aren't received for removed tracks.
-  std::vector<std::unique_ptr<webrtc::FakeVideoTrackRenderer>>
+  std::vector<std::unique_ptr<FakeVideoTrackRenderer>>
       removed_fake_video_renderers_;
 
   // For remote peer communication.
@@ -1197,10 +1191,9 @@
 
   // Store references to the video sources we've created, so that we can stop
   // them, if required.
-  std::vector<rtc::scoped_refptr<webrtc::VideoTrackSource>>
-      video_track_sources_;
+  std::vector<rtc::scoped_refptr<VideoTrackSource>> video_track_sources_;
   // `local_video_renderer_` attached to the first created local video track.
-  std::unique_ptr<webrtc::FakeVideoTrackRenderer> local_video_renderer_;
+  std::unique_ptr<FakeVideoTrackRenderer> local_video_renderer_;
 
   SdpSemantics sdp_semantics_;
   PeerConnectionInterface::RTCOfferAnswerOptions offer_answer_options_;
@@ -1230,7 +1223,7 @@
       ice_candidate_pair_change_history_;
   std::vector<PeerConnectionInterface::SignalingState>
       peer_connection_signaling_state_history_;
-  webrtc::FakeRtcEventLogFactory* event_log_factory_;
+  FakeRtcEventLogFactory* event_log_factory_;
 
   // Number of ICE candidates expected. The default is no limit.
   int candidates_expected_ = std::numeric_limits<int>::max();
@@ -1247,7 +1240,7 @@
   friend class PeerConnectionIntegrationBaseTest;
 };
 
-class MockRtcEventLogOutput : public webrtc::RtcEventLogOutput {
+class MockRtcEventLogOutput : public RtcEventLogOutput {
  public:
   virtual ~MockRtcEventLogOutput() = default;
   MOCK_METHOD(bool, IsActive, (), (const, override));
@@ -1359,7 +1352,7 @@
   int callee_video_frames_expected_ = 0;
 };
 
-class MockIceTransport : public webrtc::IceTransportInterface {
+class MockIceTransport : public IceTransportInterface {
  public:
   MockIceTransport(const std::string& name, int component)
       : internal_(std::make_unique<cricket::FakeIceTransport>(
@@ -1407,7 +1400,7 @@
     worker_thread_->SetName("PCWorkerThread", this);
     RTC_CHECK(network_thread_->Start());
     RTC_CHECK(worker_thread_->Start());
-    webrtc::metrics::Reset();
+    metrics::Reset();
   }
 
   ~PeerConnectionIntegrationBaseTest() {
@@ -1444,13 +1437,13 @@
     // are connected. This is an important distinction. Once we have separate
     // ICE and DTLS state, this check needs to use the DTLS state.
     return (callee()->ice_connection_state() ==
-                webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+                PeerConnectionInterface::kIceConnectionConnected ||
             callee()->ice_connection_state() ==
-                webrtc::PeerConnectionInterface::kIceConnectionCompleted) &&
+                PeerConnectionInterface::kIceConnectionCompleted) &&
            (caller()->ice_connection_state() ==
-                webrtc::PeerConnectionInterface::kIceConnectionConnected ||
+                PeerConnectionInterface::kIceConnectionConnected ||
             caller()->ice_connection_state() ==
-                webrtc::PeerConnectionInterface::kIceConnectionCompleted);
+                PeerConnectionInterface::kIceConnectionCompleted);
   }
 
   // When `event_log_factory` is null, the default implementation of the event
@@ -1459,8 +1452,8 @@
       const std::string& debug_name,
       const PeerConnectionFactory::Options* options,
       const RTCConfiguration* config,
-      webrtc::PeerConnectionDependencies dependencies,
-      std::unique_ptr<webrtc::FakeRtcEventLogFactory> event_log_factory,
+      PeerConnectionDependencies dependencies,
+      std::unique_ptr<FakeRtcEventLogFactory> event_log_factory,
       bool reset_encoder_factory,
       bool reset_decoder_factory,
       bool create_media_engine = true) {
@@ -1490,10 +1483,10 @@
       const std::string& debug_name,
       const PeerConnectionFactory::Options* options,
       const RTCConfiguration* config,
-      webrtc::PeerConnectionDependencies dependencies) {
+      PeerConnectionDependencies dependencies) {
     return CreatePeerConnectionWrapper(
         debug_name, options, config, std::move(dependencies),
-        std::make_unique<webrtc::FakeRtcEventLogFactory>(),
+        std::make_unique<FakeRtcEventLogFactory>(),
         /*reset_encoder_factory=*/false,
         /*reset_decoder_factory=*/false);
   }
@@ -1514,17 +1507,17 @@
     // callee PeerConnections.
     SdpSemantics original_semantics = sdp_semantics_;
     sdp_semantics_ = caller_semantics;
-    caller_ = CreatePeerConnectionWrapper(
-        "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
-        nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false);
+    caller_ = CreatePeerConnectionWrapper("Caller", nullptr, nullptr,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false);
     sdp_semantics_ = callee_semantics;
-    callee_ = CreatePeerConnectionWrapper(
-        "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
-        nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false);
+    callee_ = CreatePeerConnectionWrapper("Callee", nullptr, nullptr,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false);
     sdp_semantics_ = original_semantics;
     return caller_ && callee_;
   }
@@ -1532,24 +1525,24 @@
   bool CreatePeerConnectionWrappersWithConfig(
       const PeerConnectionInterface::RTCConfiguration& caller_config,
       const PeerConnectionInterface::RTCConfiguration& callee_config) {
-    caller_ = CreatePeerConnectionWrapper(
-        "Caller", nullptr, &caller_config,
-        webrtc::PeerConnectionDependencies(nullptr), nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false);
-    callee_ = CreatePeerConnectionWrapper(
-        "Callee", nullptr, &callee_config,
-        webrtc::PeerConnectionDependencies(nullptr), nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false);
+    caller_ = CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false);
+    callee_ = CreatePeerConnectionWrapper("Callee", nullptr, &callee_config,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false);
     return caller_ && callee_;
   }
 
   bool CreatePeerConnectionWrappersWithConfigAndDeps(
       const PeerConnectionInterface::RTCConfiguration& caller_config,
-      webrtc::PeerConnectionDependencies caller_dependencies,
+      PeerConnectionDependencies caller_dependencies,
       const PeerConnectionInterface::RTCConfiguration& callee_config,
-      webrtc::PeerConnectionDependencies callee_dependencies) {
+      PeerConnectionDependencies callee_dependencies) {
     caller_ =
         CreatePeerConnectionWrapper("Caller", nullptr, &caller_config,
                                     std::move(caller_dependencies), nullptr,
@@ -1566,16 +1559,16 @@
   bool CreatePeerConnectionWrappersWithOptions(
       const PeerConnectionFactory::Options& caller_options,
       const PeerConnectionFactory::Options& callee_options) {
-    caller_ = CreatePeerConnectionWrapper(
-        "Caller", &caller_options, nullptr,
-        webrtc::PeerConnectionDependencies(nullptr), nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false);
-    callee_ = CreatePeerConnectionWrapper(
-        "Callee", &callee_options, nullptr,
-        webrtc::PeerConnectionDependencies(nullptr), nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false);
+    caller_ = CreatePeerConnectionWrapper("Caller", &caller_options, nullptr,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false);
+    callee_ = CreatePeerConnectionWrapper("Callee", &callee_options, nullptr,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false);
     return caller_ && callee_;
   }
 
@@ -1583,10 +1576,10 @@
     PeerConnectionInterface::RTCConfiguration default_config;
     caller_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
         "Caller", nullptr, &default_config,
-        webrtc::PeerConnectionDependencies(nullptr));
+        PeerConnectionDependencies(nullptr));
     callee_ = CreatePeerConnectionWrapperWithFakeRtcEventLog(
         "Callee", nullptr, &default_config,
-        webrtc::PeerConnectionDependencies(nullptr));
+        PeerConnectionDependencies(nullptr));
     return caller_ && callee_;
   }
 
@@ -1596,7 +1589,7 @@
         new FakeRTCCertificateGenerator());
     cert_generator->use_alternate_key();
 
-    webrtc::PeerConnectionDependencies dependencies(nullptr);
+    PeerConnectionDependencies dependencies(nullptr);
     dependencies.cert_generator = std::move(cert_generator);
     return CreatePeerConnectionWrapper("New Peer", nullptr, nullptr,
                                        std::move(dependencies), nullptr,
@@ -1606,12 +1599,12 @@
 
   bool CreateOneDirectionalPeerConnectionWrappers(bool caller_to_callee) {
     caller_ = CreatePeerConnectionWrapper(
-        "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        "Caller", nullptr, nullptr, PeerConnectionDependencies(nullptr),
         nullptr,
         /*reset_encoder_factory=*/!caller_to_callee,
         /*reset_decoder_factory=*/caller_to_callee);
     callee_ = CreatePeerConnectionWrapper(
-        "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
+        "Callee", nullptr, nullptr, PeerConnectionDependencies(nullptr),
         nullptr,
         /*reset_encoder_factory=*/caller_to_callee,
         /*reset_decoder_factory=*/!caller_to_callee);
@@ -1619,18 +1612,18 @@
   }
 
   bool CreatePeerConnectionWrappersWithoutMediaEngine() {
-    caller_ = CreatePeerConnectionWrapper(
-        "Caller", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
-        nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false,
-        /*create_media_engine=*/false);
-    callee_ = CreatePeerConnectionWrapper(
-        "Callee", nullptr, nullptr, webrtc::PeerConnectionDependencies(nullptr),
-        nullptr,
-        /*reset_encoder_factory=*/false,
-        /*reset_decoder_factory=*/false,
-        /*create_media_engine=*/false);
+    caller_ = CreatePeerConnectionWrapper("Caller", nullptr, nullptr,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false,
+                                          /*create_media_engine=*/false);
+    callee_ = CreatePeerConnectionWrapper("Callee", nullptr, nullptr,
+                                          PeerConnectionDependencies(nullptr),
+                                          nullptr,
+                                          /*reset_encoder_factory=*/false,
+                                          /*reset_decoder_factory=*/false,
+                                          /*create_media_engine=*/false);
     return caller_ && callee_;
   }
 
@@ -1700,7 +1693,7 @@
 
   // Messages may get lost on the unreliable DataChannel, so we send multiple
   // times to avoid test flakiness.
-  void SendRtpDataWithRetries(webrtc::DataChannelInterface* dc,
+  void SendRtpDataWithRetries(DataChannelInterface* dc,
                               const std::string& data,
                               int retries) {
     for (int i = 0; i < retries; ++i) {
diff --git a/pc/test/mock_peer_connection_observers.h b/pc/test/mock_peer_connection_observers.h
index e9d97a9..6222ef7 100644
--- a/pc/test/mock_peer_connection_observers.h
+++ b/pc/test/mock_peer_connection_observers.h
@@ -254,7 +254,7 @@
 };
 
 class MockCreateSessionDescriptionObserver
-    : public webrtc::CreateSessionDescriptionObserver {
+    : public CreateSessionDescriptionObserver {
  public:
   MockCreateSessionDescriptionObserver()
       : called_(false),
@@ -266,7 +266,7 @@
     error_ = "";
     desc_.reset(desc);
   }
-  void OnFailure(webrtc::RTCError error) override {
+  void OnFailure(RTCError error) override {
     MutexLock lock(&mutex_);
     called_ = true;
     error_ = error.message();
@@ -295,8 +295,7 @@
   std::unique_ptr<SessionDescriptionInterface> desc_ RTC_GUARDED_BY(mutex_);
 };
 
-class MockSetSessionDescriptionObserver
-    : public webrtc::SetSessionDescriptionObserver {
+class MockSetSessionDescriptionObserver : public SetSessionDescriptionObserver {
  public:
   static rtc::scoped_refptr<MockSetSessionDescriptionObserver> Create() {
     return rtc::make_ref_counted<MockSetSessionDescriptionObserver>();
@@ -312,7 +311,7 @@
     called_ = true;
     error_ = "";
   }
-  void OnFailure(webrtc::RTCError error) override {
+  void OnFailure(RTCError error) override {
     MutexLock lock(&mutex_);
     called_ = true;
     error_ = error.message();
@@ -375,14 +374,14 @@
   absl::optional<RTCError> error_;
 };
 
-class MockDataChannelObserver : public webrtc::DataChannelObserver {
+class MockDataChannelObserver : public DataChannelObserver {
  public:
   struct Message {
     std::string data;
     bool binary;
   };
 
-  explicit MockDataChannelObserver(webrtc::DataChannelInterface* channel)
+  explicit MockDataChannelObserver(DataChannelInterface* channel)
       : channel_(channel) {
     channel_->RegisterObserver(this);
     states_.push_back(channel_->state());
@@ -419,12 +418,12 @@
   }
 
  private:
-  rtc::scoped_refptr<webrtc::DataChannelInterface> channel_;
+  rtc::scoped_refptr<DataChannelInterface> channel_;
   std::vector<DataChannelInterface::DataState> states_;
   std::vector<Message> messages_;
 };
 
-class MockStatsObserver : public webrtc::StatsObserver {
+class MockStatsObserver : public StatsObserver {
  public:
   MockStatsObserver() : called_(false), stats_() {}
   virtual ~MockStatsObserver() {}
@@ -576,7 +575,7 @@
 };
 
 // Helper class that just stores the report from the callback.
-class MockRTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback {
+class MockRTCStatsCollectorCallback : public RTCStatsCollectorCallback {
  public:
   rtc::scoped_refptr<const RTCStatsReport> report() { return report_; }
 
diff --git a/pc/test/rtp_transport_test_util.h b/pc/test/rtp_transport_test_util.h
index 8aeaf07..563014f 100644
--- a/pc/test/rtp_transport_test_util.h
+++ b/pc/test/rtp_transport_test_util.h
@@ -33,9 +33,7 @@
     rtp_transport->SubscribeReadyToSend(
         this, [this](bool arg) { OnReadyToSend(arg); });
     rtp_transport->SetUnDemuxableRtpPacketReceivedHandler(
-        [this](webrtc::RtpPacketReceived& packet) {
-          OnUndemuxableRtpPacket(packet);
-        });
+        [this](RtpPacketReceived& packet) { OnUndemuxableRtpPacket(packet); });
     rtp_transport->SubscribeSentPacket(this,
                                        [this](const rtc::SentPacket& packet) {
                                          sent_packet_count_++;
diff --git a/pc/test/svc_e2e_tests.cc b/pc/test/svc_e2e_tests.cc
index ae35c7f..412027b 100644
--- a/pc/test/svc_e2e_tests.cc
+++ b/pc/test/svc_e2e_tests.cc
@@ -160,10 +160,9 @@
 // encoder and decoder level.
 class SvcVideoQualityAnalyzer : public DefaultVideoQualityAnalyzer {
  public:
-  using SpatialTemporalLayerCounts =
-      webrtc::flat_map<int, webrtc::flat_map<int, int>>;
+  using SpatialTemporalLayerCounts = flat_map<int, flat_map<int, int>>;
 
-  explicit SvcVideoQualityAnalyzer(webrtc::Clock* clock)
+  explicit SvcVideoQualityAnalyzer(Clock* clock)
       : DefaultVideoQualityAnalyzer(clock,
                                     test::GetGlobalMetricsLogger(),
                                     DefaultVideoQualityAnalyzerOptions{
@@ -315,9 +314,9 @@
   if (UseDependencyDescriptor()) {
     trials += "WebRTC-DependencyDescriptorAdvertised/Enabled/";
   }
-  webrtc::test::ScopedFieldTrials override_trials(AppendFieldTrials(trials));
+  test::ScopedFieldTrials override_trials(AppendFieldTrials(trials));
   std::unique_ptr<NetworkEmulationManager> network_emulation_manager =
-      CreateNetworkEmulationManager(webrtc::TimeMode::kSimulated);
+      CreateNetworkEmulationManager(TimeMode::kSimulated);
   auto analyzer = std::make_unique<SvcVideoQualityAnalyzer>(
       network_emulation_manager->time_controller()->GetClock());
   SvcVideoQualityAnalyzer* analyzer_ptr = analyzer.get();
diff --git a/pc/video_rtp_receiver_unittest.cc b/pc/video_rtp_receiver_unittest.cc
index 5ff7360..e972917 100644
--- a/pc/video_rtp_receiver_unittest.cc
+++ b/pc/video_rtp_receiver_unittest.cc
@@ -94,7 +94,7 @@
              [&]() { receiver_->SetMediaChannel(media_channel); });
   }
 
-  webrtc::VideoTrackSourceInterface* Source() {
+  VideoTrackSourceInterface* Source() {
     return receiver_->streams()[0]->FindVideoTrack("receiver")->GetSource();
   }
 
diff --git a/pc/video_rtp_track_source_unittest.cc b/pc/video_rtp_track_source_unittest.cc
index 13728c7..55632ce 100644
--- a/pc/video_rtp_track_source_unittest.cc
+++ b/pc/video_rtp_track_source_unittest.cc
@@ -109,11 +109,11 @@
 
 class TestFrame : public RecordableEncodedFrame {
  public:
-  rtc::scoped_refptr<const webrtc::EncodedImageBufferInterface> encoded_buffer()
+  rtc::scoped_refptr<const EncodedImageBufferInterface> encoded_buffer()
       const override {
     return nullptr;
   }
-  absl::optional<webrtc::ColorSpace> color_space() const override {
+  absl::optional<ColorSpace> color_space() const override {
     return absl::nullopt;
   }
   VideoCodecType codec() const override { return kVideoCodecGeneric; }
diff --git a/pc/video_track.h b/pc/video_track.h
index 13a51c4..e504182 100644
--- a/pc/video_track.h
+++ b/pc/video_track.h
@@ -70,7 +70,7 @@
   // Implements ObserverInterface. Observes `video_source_` state.
   void OnChanged() override;
 
-  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker signaling_thread_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_;
   rtc::Thread* const worker_thread_;
   const rtc::scoped_refptr<
       VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface>>
diff --git a/pc/video_track_source_proxy.h b/pc/video_track_source_proxy.h
index 8500a98..40d2423 100644
--- a/pc/video_track_source_proxy.h
+++ b/pc/video_track_source_proxy.h
@@ -52,7 +52,7 @@
                         rtc::VideoSinkInterface<RecordableEncodedFrame>*)
 PROXY_SECONDARY_METHOD1(void,
                         ProcessConstraints,
-                        const webrtc::VideoTrackSourceConstraints&)
+                        const VideoTrackSourceConstraints&)
 END_PROXY_MAP(VideoTrackSource)
 
 }  // namespace webrtc
diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc
index 7d896e2..da024ea 100644
--- a/pc/webrtc_sdp.cc
+++ b/pc/webrtc_sdp.cc
@@ -2626,7 +2626,7 @@
     int* msid_signaling,
     TransportDescription* transport,
     std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
-    webrtc::SdpParseError* error) {
+    SdpParseError* error) {
   std::unique_ptr<MediaContentDescription> media_desc;
   if (media_type == cricket::MediaType::MEDIA_TYPE_AUDIO) {
     media_desc = std::make_unique<AudioContentDescription>();
diff --git a/tools_webrtc/remove_extra_namespace.py b/tools_webrtc/remove_extra_namespace.py
new file mode 100755
index 0000000..21ac2d1
--- /dev/null
+++ b/tools_webrtc/remove_extra_namespace.py
@@ -0,0 +1,93 @@
+#!/usr/bin/env vpython3
+
+# Copyright (c) 2023 The WebRTC project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+"""Remove extra namespace qualifications
+
+Looks for names that don't need to be qualified by namespace, and deletes
+the qualifier.
+
+Depends on namespace names being properly formatted
+"""
+import os
+import glob
+import sys
+import re
+import argparse
+
+
+def remove_extra_namespace_from_file(namespace, filename):
+    print('Processing namespace', namespace, 'file', filename)
+    with open(filename) as file:
+        newfile = open(filename + '.NEW', 'w')
+        namespaces = []
+        changes = 0
+        for line in file:
+            match = re.match(r'namespace (\S+) {', line)
+            if match is not None:
+                namespaces.insert(0, match.group(1))
+                newfile.write(line)
+                continue
+            match = re.match(r'}\s+// namespace (\S+)$', line)
+            if match is not None:
+                if match.group(1) != namespaces[0]:
+                    print('Namespace mismatch')
+                    raise RuntimeError('Namespace mismatch')
+                del namespaces[0]
+                newfile.write(line)
+                continue
+            # Remove namespace usage. Only replacing when target
+            # namespace is the innermost namespace.
+            if len(namespaces) > 0 and namespaces[0] == namespace:
+                # Note that in namespace foo, we match neither ::foo::name
+                # nor morefoo::name
+                # Neither do we match foo:: when it is not followed by
+                # an identifier character.
+                usage_re = r'(?<=[^a-z:]){}::(?=[a-zA-Z])'.format(
+                    namespaces[0])
+                if re.search(usage_re, line):
+                    line = re.sub(usage_re, '', line)
+                    changes += 1
+            newfile.write(line)
+    if changes > 0:
+        print('Made', changes, 'changes to', filename)
+        os.remove(filename)
+        os.rename(filename + '.NEW', filename)
+    else:
+        os.remove(filename + '.NEW')
+
+
+def remove_extra_namespace_from_files(namespace, files):
+    for file in files:
+        if os.path.isfile(file):
+            if re.search(r'\.(h|cc)$', file):
+                remove_extra_namespace_from_file(namespace, file)
+        elif os.path.isdir(file):
+            if file in ('third_party', 'out'):
+                continue
+            subfiles = glob.glob(file + '/*')
+            remove_extra_namespace_from_files(namespace, subfiles)
+        else:
+            print(file, 'is not a file or directory, ignoring')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='remove_extra_namespace.py',
+        description=__doc__.strip().splitlines()[0],
+        epilog=''.join(__doc__.splitlines(True)[1:]),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument('--namespace')
+    parser.add_argument('files', nargs=argparse.REMAINDER)
+    args = parser.parse_args()
+    return remove_extra_namespace_from_files(args.namespace, args.files)
+
+
+if __name__ == '__main__':
+    sys.exit(main())