Shutdown PeerConnectionDependencyFactory before Blink shutdown

content/renderer/media/webrtc/peer_connection_dependency_factory.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 130 matching lines @@
 }
 
 const scoped_refptr<webrtc::PeerConnectionFactoryInterface>&
 PeerConnectionDependencyFactory::GetPcFactory() {
   if (!pc_factory_.get())
     CreatePeerConnectionFactory();
   CHECK(pc_factory_.get());
   return pc_factory_;
 }
 
-void PeerConnectionDependencyFactory::WillDestroyCurrentMessageLoop() {
-  CleanupPeerConnectionFactory();
-}
-
 void PeerConnectionDependencyFactory::CreatePeerConnectionFactory() {
   DCHECK(!pc_factory_.get());
   DCHECK(!signaling_thread_);
   DCHECK(!worker_thread_);
   DCHECK(!network_manager_);
   DCHECK(!socket_factory_);
   DCHECK(!chrome_signaling_thread_.IsRunning());
   DCHECK(!chrome_worker_thread_.IsRunning());
 
   DVLOG(1) << "PeerConnectionDependencyFactory::CreatePeerConnectionFactory()";
 
 #if BUILDFLAG(RTC_USE_H264)
   // Building /w |rtc_use_h264|, is the corresponding run-time feature enabled?
   if (base::FeatureList::IsEnabled(kWebRtcH264WithOpenH264FFmpeg)) {
     // |H264DecoderImpl| may be used which depends on FFmpeg, therefore we need
     // to initialize FFmpeg before going further.
     media::FFmpegGlue::InitializeFFmpeg();
   } else {
     // Feature is to be disabled, no need to make sure FFmpeg is initialized.
     webrtc::DisableRtcUseH264();
   }
 #endif
 
-  base::MessageLoop::current()->AddDestructionObserver(this);
   // To allow sending to the signaling/worker threads.
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
 
   EnsureWebRtcAudioDeviceImpl();
 
   CHECK(chrome_signaling_thread_.Start());
   CHECK(chrome_worker_thread_.Start());
 
   base::WaitableEvent start_worker_event(
@@ skipping 85 matching lines @@
   std::string group_name =
       base::FieldTrialList::FindFullName("WebRTC-PeerConnectionDTLS1.2");
   if (StartsWith(group_name, "Control", base::CompareCase::SENSITIVE))
     factory_options.ssl_max_version = rtc::SSL_PROTOCOL_DTLS_10;
 
   pc_factory_->SetOptions(factory_options);
 
   event->Signal();
 }
 
+void PeerConnectionDependencyFactory::ShutDown() {
+  CleanupPeerConnectionFactory();
+}
+
 bool PeerConnectionDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
 }
 
 scoped_refptr<webrtc::PeerConnectionInterface>
 PeerConnectionDependencyFactory::CreatePeerConnection(
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     blink::WebFrame* web_frame,
     webrtc::PeerConnectionObserver* observer) {
   CHECK(web_frame);
@@ skipping 265 matching lines @@
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   DCHECK(CalledOnValidThread());
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content