Split libjingle's signaling thread from the UI thread

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 <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 151 matching lines @@
   rtc::NetworkManager* network_manager_;
   rtc::PacketSocketFactory* socket_factory_;
 };
 
 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
+      chrome_signaling_thread_("Chrome_libJingle_Signaling"),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
 }
 
 PeerConnectionDependencyFactory::~PeerConnectionDependencyFactory() {
   CleanupPeerConnectionFactory();
   if (aec_dump_message_filter_.get())
     aec_dump_message_filter_->RemoveDelegate(this);
 }
 
 blink::WebRTCPeerConnectionHandler*
 PeerConnectionDependencyFactory::CreateRTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client) {
+  if (!GetPcFactory().get())
+    return NULL;
   // Save histogram data so we can see how much PeerConnetion is used.
   // The histogram counts the number of calls to the JS API
   // webKitRTCPeerConnection.
   UpdateWebRTCMethodCount(WEBKIT_RTC_PEER_CONNECTION);
 
-  return new RTCPeerConnectionHandler(client, this);
+  return new RTCPeerConnectionHandler(client, this, GetWebRtcSignalingThread());
 }
 
 bool PeerConnectionDependencyFactory::InitializeMediaStreamAudioSource(
     int render_view_id,
     const blink::WebMediaConstraints& audio_constraints,
     MediaStreamAudioSource* source_data) {
   DVLOG(1) << "InitializeMediaStreamAudioSources()";
 
   // Do additional source initialization if the audio source is a valid
   // microphone or tab audio.
@@ skipping 66 matching lines @@
   CHECK(pc_factory_.get());
   return pc_factory_;
 }
 
 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()";
 
+  // To allow sending to the signaling/worker threads.
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
-  signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
-  CHECK(signaling_thread_);
 
+  CHECK(chrome_signaling_thread_.Start());
   CHECK(chrome_worker_thread_.Start());
 
   base::WaitableEvent start_worker_event(true, false);
   chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &PeerConnectionDependencyFactory::InitializeWorkerThread,
       base::Unretained(this),
       &worker_thread_,
       &start_worker_event));
-  start_worker_event.Wait();
-  CHECK(worker_thread_);
 
   base::WaitableEvent create_network_manager_event(true, false);
   chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &PeerConnectionDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
       base::Unretained(this),
       &create_network_manager_event));
+
+  start_worker_event.Wait();
   create_network_manager_event.Wait();
 
-  socket_factory_.reset(
-      new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
+  CHECK(worker_thread_);
 
   // Init SSL, which will be needed by PeerConnection.
 #if defined(USE_OPENSSL)
   if (!rtc::InitializeSSL()) {
     LOG(ERROR) << "Failed on InitializeSSL.";
     NOTREACHED();
     return;
   }
 #else
   // TODO(ronghuawu): Replace this call with InitializeSSL.
   net::EnsureNSSSSLInit();
 #endif
 
+  base::WaitableEvent start_signaling_event(true, false);
+  chrome_signaling_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &PeerConnectionDependencyFactory::InitializeSignalingThread,
+      base::Unretained(this),
+      RenderThreadImpl::current()->GetGpuFactories(),
+      &start_signaling_event));
+
+  // TODO(xians): Remove the following code after kDisableAudioTrackProcessing
+  // is removed.
+  if (!MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled()) {
+    aec_dump_message_filter_ = AecDumpMessageFilter::Get();
+    // In unit tests not creating a message filter, |aec_dump_message_filter_|
+    // will be NULL. We can just ignore that. Other unit tests and browser tests
+    // ensure that we do get the filter when we should.
+    if (aec_dump_message_filter_.get())
+      aec_dump_message_filter_->AddDelegate(this);
+  }
+
+  start_signaling_event.Wait();
+  CHECK(signaling_thread_);
+}
+
+void PeerConnectionDependencyFactory::InitializeSignalingThread(
+    const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories,
+    base::WaitableEvent* event) {
+  DCHECK(chrome_signaling_thread_.task_runner()->BelongsToCurrentThread());
+  DCHECK(worker_thread_);
+  DCHECK(p2p_socket_dispatcher_.get());
+
+  jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
+  jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
+  signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
+
+  EnsureWebRtcAudioDeviceImpl();
+
+  socket_factory_.reset(
+      new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
+
   scoped_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
   scoped_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-  scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories =
-      RenderThreadImpl::current()->GetGpuFactories();
-  if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding)) {
-    if (gpu_factories.get())
+  if (gpu_factories.get()) {
+    if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding))
       decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
-  }
 
-  if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWEncoding)) {
-    if (gpu_factories.get())
+    if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWEncoding))
       encoder_factory.reset(new RTCVideoEncoderFactory(gpu_factories));
   }
 
 #if defined(OS_ANDROID)
   if (!media::MediaCodecBridge::SupportsSetParameters())
     encoder_factory.reset();
 #endif
 
-  EnsureWebRtcAudioDeviceImpl();
+  pc_factory_ = webrtc::CreatePeerConnectionFactory(
+      worker_thread_, signaling_thread_, audio_device_.get(),
+      encoder_factory.release(), decoder_factory.release());
+  CHECK(pc_factory_.get());
 
-  scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
-      webrtc::CreatePeerConnectionFactory(worker_thread_,
-                                          signaling_thread_,
-                                          audio_device_.get(),
-                                          encoder_factory.release(),
-                                          decoder_factory.release()));
-  CHECK(factory.get());
-
-  pc_factory_ = factory;
   webrtc::PeerConnectionFactoryInterface::Options factory_options;
   factory_options.disable_sctp_data_channels = false;
   factory_options.disable_encryption =
       cmd_line->HasSwitch(switches::kDisableWebRtcEncryption);
   pc_factory_->SetOptions(factory_options);
 
-  // TODO(xians): Remove the following code after kDisableAudioTrackProcessing
-  // is removed.
-  if (!MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled()) {
-    aec_dump_message_filter_ = AecDumpMessageFilter::Get();
-    // In unit tests not creating a message filter, |aec_dump_message_filter_|
-    // will be NULL. We can just ignore that. Other unit tests and browser tests
-    // ensure that we do get the filter when we should.
-    if (aec_dump_message_filter_.get())
-      aec_dump_message_filter_->AddDelegate(this);
-  }
+  event->Signal();
 }
 
 bool PeerConnectionDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
 }
 
 scoped_refptr<webrtc::PeerConnectionInterface>
 PeerConnectionDependencyFactory::CreatePeerConnection(
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const webrtc::MediaConstraintsInterface* constraints,
@@ skipping 217 matching lines @@
   DCHECK_GE(render_view_id, 0);
 
   EnsureWebRtcAudioDeviceImpl();
   DCHECK(GetWebRtcAudioDevice());
   return WebRtcAudioCapturer::CreateCapturer(render_view_id, device_info,
                                              constraints,
                                              GetWebRtcAudioDevice(),
                                              audio_source);
 }
 
-void PeerConnectionDependencyFactory::AddNativeAudioTrackToBlinkTrack(
-    webrtc::MediaStreamTrackInterface* native_track,
-    const blink::WebMediaStreamTrack& webkit_track,
-    bool is_local_track) {
-  DCHECK(!webkit_track.isNull() && !webkit_track.extraData());
-  DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio,
-            webkit_track.source().type());
-  blink::WebMediaStreamTrack track = webkit_track;
-
-  DVLOG(1) << "AddNativeTrackToBlinkTrack() audio";
-  track.setExtraData(
-      new MediaStreamTrack(
-          static_cast<webrtc::AudioTrackInterface*>(native_track),
-          is_local_track));
-}
-
 scoped_refptr<base::MessageLoopProxy>
 PeerConnectionDependencyFactory::GetWebRtcWorkerThread() const {
   DCHECK(CalledOnValidThread());
   return chrome_worker_thread_.message_loop_proxy();
 }
 
 scoped_refptr<base::MessageLoopProxy>
 PeerConnectionDependencyFactory::GetWebRtcSignalingThread() const {
   DCHECK(CalledOnValidThread());
-  return RenderThreadImpl::current()->GetMessageLoop()->message_loop_proxy();
+  return chrome_signaling_thread_.message_loop_proxy();
 }
 
 void PeerConnectionDependencyFactory::OnAecDumpFile(
     const IPC::PlatformFileForTransit& file_handle) {
   DCHECK(CalledOnValidThread());
   DCHECK(!MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled());
   DCHECK(PeerConnectionFactoryCreated());
 
   base::File file = IPC::PlatformFileForTransitToFile(file_handle);
   DCHECK(file.IsValid());
@@ skipping 16 matching lines @@
 }
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content