Shutdown PeerConnectionDependencyFactory before Blink shutdown

content/renderer/media/webrtc/peer_connection_dependency_factory.h

 // 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.
 
 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
 #define CONTENT_RENDERER_MEDIA_WEBRTC_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
 
 #include <string>
 
 #include "base/files/file.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/webrtc/stun_field_trial.h"
 #include "content/renderer/p2p/socket_dispatcher.h"
 #include "ipc/ipc_platform_file.h"
 #include "third_party/webrtc/api/peerconnectioninterface.h"
 #include "third_party/webrtc/p2p/stunprober/stunprober.h"
 
 namespace base {
@@ skipping 25 matching lines @@
 class IpcNetworkManager;
 class IpcPacketSocketFactory;
 class WebRtcAudioDeviceImpl;
 class WebRtcLoggingHandlerImpl;
 class WebRtcLoggingMessageFilter;
 class WebRtcVideoCapturerAdapter;
 struct StreamDeviceInfo;
 
 // Object factory for RTC PeerConnections.
 class CONTENT_EXPORT PeerConnectionDependencyFactory
-    : NON_EXPORTED_BASE(base::MessageLoop::DestructionObserver),
-      NON_EXPORTED_BASE(public base::NonThreadSafe) {
+    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
   PeerConnectionDependencyFactory(
       P2PSocketDispatcher* p2p_socket_dispatcher);
-  ~PeerConnectionDependencyFactory() override;
+  virtual ~PeerConnectionDependencyFactory();
 
   // Create a RTCPeerConnectionHandler object that implements the
   // WebKit WebRTCPeerConnectionHandler interface.
   blink::WebRTCPeerConnectionHandler* CreateRTCPeerConnectionHandler(
       blink::WebRTCPeerConnectionHandlerClient* client);
 
   // Asks the PeerConnection factory to create a Local MediaStream object.
   virtual scoped_refptr<webrtc::MediaStreamInterface>
       CreateLocalMediaStream(const std::string& label);
 
@@ skipping 33 matching lines @@
       const std::string& sdp_mid,
       int sdp_mline_index,
       const std::string& sdp);
 
   WebRtcAudioDeviceImpl* GetWebRtcAudioDevice();
 
   void EnsureInitialized();
   scoped_refptr<base::SingleThreadTaskRunner> GetWebRtcWorkerThread() const;
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetWebRtcSignalingThread()
       const;
+  void ShutDown();
 
  protected:
   // Asks the PeerConnection factory to create a Local VideoTrack object with
   // the video source using |capturer|.
   virtual scoped_refptr<webrtc::VideoTrackInterface>
       CreateLocalVideoTrack(const std::string& id,
                             cricket::VideoCapturer* capturer);
 
   virtual const scoped_refptr<webrtc::PeerConnectionFactoryInterface>&
       GetPcFactory();
   virtual bool PeerConnectionFactoryCreated();
 
   // Helper method to create a WebRtcAudioDeviceImpl.
   void EnsureWebRtcAudioDeviceImpl();
 
  private:
-  // Implement base::MessageLoop::DestructionObserver.
-  // This makes sure the libjingle PeerConnectionFactory is released before
-  // the renderer message loop is destroyed.
-  void WillDestroyCurrentMessageLoop() override;
-
   // Functions related to Stun probing trial to determine how fast we could send
   // Stun request without being dropped by NAT.
   void TryScheduleStunProbeTrial();
   void StartStunProbeTrialOnWorkerThread(const std::string& params);
 
   // Creates |pc_factory_|, which in turn is used for
   // creating PeerConnection objects.
   void CreatePeerConnectionFactory();
 
   void InitializeSignalingThread(
@@ skipping 25 matching lines @@
   rtc::Thread* worker_thread_;
   base::Thread chrome_signaling_thread_;
   base::Thread chrome_worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(PeerConnectionDependencyFactory);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_PEER_CONNECTION_DEPENDENCY_FACTORY_H_