Add deletion observer to P2PSocketDispatcher.

content/renderer/media/media_stream_impl.cc

 // Copyright (c) 2012 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/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "content/renderer/media/capture_video_decoder.h"
 #include "content/renderer/media/media_stream_extra_data.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_dispatcher.h"
 #include "content/renderer/media/peer_connection_handler.h"
 #include "content/renderer/media/peer_connection_handler_jsep.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/media/video_capture_module_impl.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/p2p/ipc_network_manager.h"
 #include "content/renderer/p2p/ipc_socket_factory.h"
-#include "content/renderer/p2p/socket_dispatcher.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "media/base/message_loop_factory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamComponent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamDescriptor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebVector.h"
 
@@ skipping 47 matching lines @@
       media_stream_dispatcher_(media_stream_dispatcher),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       network_manager_(NULL),
       vc_manager_(vc_manager),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
 }
 
 MediaStreamImpl::~MediaStreamImpl() {
-  DCHECK(local_media_streams_.empty());
-  if (dependency_factory_.get())
-    dependency_factory_->ReleasePeerConnectionFactory();
-  if (network_manager_) {
-    // The network manager needs to free its resources on the thread they were
-    // created, which is the worked thread.
-    if (chrome_worker_thread_.IsRunning()) {
-      chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-          &MediaStreamImpl::DeleteIpcNetworkManager,
-          base::Unretained(this)));
-      // Stopping the thread will wait until all tasks have been
-      // processed before returning. We wait for the above task to finish before
-      // letting the destructor continue to avoid any potential race issues.
-      chrome_worker_thread_.Stop();
-    } else {
-      NOTREACHED() << "Worker thread not running.";
-    }
-  }
+  CleanupPeerConnectionFactory();
 }
 
 WebKit::WebPeerConnectionHandler* MediaStreamImpl::CreatePeerConnectionHandler(
     WebKit::WebPeerConnectionHandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
   // The histogram counts the number of calls to the JS API
   // webKitDeprecatedPeerConnection.
   UpdateWebRTCMethodCount(kWebkitDeprecatedPeerConnection);
   DCHECK(CalledOnValidThread());
   if (!EnsurePeerConnectionFactory())
@@ skipping 251 matching lines @@
                << "Stopping stream " << it->first;
       media_stream_dispatcher_->StopStream(it->first);
       local_media_streams_.erase(it);
       it = local_media_streams_.begin();
     } else {
       ++it;
     }
   }
 }
 
+void MediaStreamImpl::OnSocketDispatcherDestroyed() {
+  CleanupPeerConnectionFactory();
+}
+
 void MediaStreamImpl::InitializeWorkerThread(talk_base::Thread** thread,
                                              base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentThread();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
 void MediaStreamImpl::CreateIpcNetworkManagerOnWorkerThread(
     base::WaitableEvent* event) {
@@ skipping 34 matching lines @@
     DCHECK(worker_thread_);
   }
 
   if (!network_manager_) {
     base::WaitableEvent event(true, false);
     chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
           &MediaStreamImpl::CreateIpcNetworkManagerOnWorkerThread,
           base::Unretained(this),
           &event));
     event.Wait();
+    p2p_socket_dispatcher_->AddDestructionObserver(this);
   }
 
   if (!socket_factory_.get()) {
     socket_factory_.reset(
         new content::IpcPacketSocketFactory(p2p_socket_dispatcher_));
   }
 
   if (!dependency_factory_->PeerConnectionFactoryCreated()) {
     if (!dependency_factory_->CreatePeerConnectionFactory(
             worker_thread_,
             signaling_thread_,
             p2p_socket_dispatcher_,
             network_manager_,
             socket_factory_.get())) {
       LOG(ERROR) << "Could not create PeerConnection factory";
       return false;
     }
   }
 
   return true;
 }
 
+void MediaStreamImpl::CleanupPeerConnectionFactory() {
+  if (dependency_factory_.get())
+    dependency_factory_->ReleasePeerConnectionFactory();
+  if (network_manager_) {
+    // The network manager needs to free its resources on the thread they were
+    // created, which is the worked thread.
+    if (chrome_worker_thread_.IsRunning()) {
+      chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+          &MediaStreamImpl::DeleteIpcNetworkManager,
+          base::Unretained(this)));
+      // Stopping the thread will wait until all tasks have been
+      // processed before returning. We wait for the above task to finish before
+      // letting the the function continue to avoid any potential race issues.
+      chrome_worker_thread_.Stop();
+    } else {
+      NOTREACHED() << "Worker thread not running.";
+    }
+    p2p_socket_dispatcher_->RemoveDestructionObserver(this);
+  }
+}
+
 scoped_refptr<media::VideoDecoder> MediaStreamImpl::CreateLocalVideoDecoder(
     webrtc::MediaStreamInterface* stream,
     media::MessageLoopFactory* message_loop_factory) {
   if (!stream->video_tracks() || stream->video_tracks()->count() == 0)
     return NULL;
 
   int video_session_id =
       media_stream_dispatcher_->video_session_id(stream->label(), 0);
   media::VideoCaptureCapability capability;
   capability.width = kVideoCaptureWidth;
@@ skipping 86 matching lines @@
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::MediaStreamInterface* remote_stream)
     : remote_stream_(remote_stream) {
 }
 MediaStreamExtraData::MediaStreamExtraData(
     webrtc::LocalMediaStreamInterface* local_stream)
     : local_stream_(local_stream) {
 }
 MediaStreamExtraData::~MediaStreamExtraData() {
 }