Added network thread to rtc::BaseChannel

webrtc/pc/channelmanager.cc

 /*
  *  Copyright 2004 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.
  */
 
@@ skipping 26 matching lines @@
 static DataEngineInterface* ConstructDataEngine() {
 #ifdef HAVE_SCTP
   return new HybridDataEngine(new RtpDataEngine(), new SctpDataEngine());
 #else
   return new RtpDataEngine();
 #endif
 }
 
 ChannelManager::ChannelManager(MediaEngineInterface* me,
                                DataEngineInterface* dme,
-                               rtc::Thread* worker_thread) {
-  Construct(me, dme, worker_thread);
+                               rtc::Thread* thread) {
+  Construct(me, dme, thread, thread);
 }
 
 ChannelManager::ChannelManager(MediaEngineInterface* me,
-                               rtc::Thread* worker_thread) {
-  Construct(me,
-            ConstructDataEngine(),
-            worker_thread);
+                               rtc::Thread* worker_thread,
+                               rtc::Thread* network_thread) {
+  Construct(me, ConstructDataEngine(), worker_thread, network_thread);
 }
 
 void ChannelManager::Construct(MediaEngineInterface* me,
                                DataEngineInterface* dme,
-                               rtc::Thread* worker_thread) {
+                               rtc::Thread* worker_thread,
+                               rtc::Thread* network_thread) {
   media_engine_.reset(me);
   data_media_engine_.reset(dme);
   initialized_ = false;
   main_thread_ = rtc::Thread::Current();
   worker_thread_ = worker_thread;
+  network_thread_ = network_thread;
   audio_output_volume_ = kNotSetOutputVolume;
   capturing_ = false;
   enable_rtx_ = false;
 }
 
 ChannelManager::~ChannelManager() {
   if (initialized_) {
     Terminate();
     // If srtp is initialized (done by the Channel) then we must call
     // srtp_shutdown to free all crypto kernel lists. But we need to make sure
@@ skipping 61 matching lines @@
 void ChannelManager::GetSupportedDataCodecs(
     std::vector<DataCodec>* codecs) const {
   *codecs = data_media_engine_->data_codecs();
 }
 
 bool ChannelManager::Init() {
   ASSERT(!initialized_);
   if (initialized_) {
     return false;
   }
-  ASSERT(worker_thread_ != NULL);
-  if (!worker_thread_) {
-    return false;
-  }
-  if (worker_thread_ != rtc::Thread::Current()) {
-    // Do not allow invoking calls to other threads on the worker thread.
-    worker_thread_->Invoke<bool>(rtc::Bind(
-        &rtc::Thread::SetAllowBlockingCalls, worker_thread_, false));
+  RTC_DCHECK(network_thread_);
+  RTC_DCHECK(worker_thread_);
+  if (!network_thread_->IsCurrent()) {
+    // Do not allow invoking calls to other threads on the network thread.
+    network_thread_->Invoke<bool>(
+        rtc::Bind(&rtc::Thread::SetAllowBlockingCalls, network_thread_, false));
   }
 
-  initialized_ = worker_thread_->Invoke<bool>(Bind(
-      &ChannelManager::InitMediaEngine_w, this));
-  ASSERT(initialized_);
-  if (!initialized_) {
-    return false;
-  }
+  initialized_ =
+      worker_thread_->Invoke<bool>([this] { return media_engine_->Init(); });
+  RTC_DCHECK(initialized_);
 
   // If audio_output_volume_ has been set via SetOutputVolume(), set the
   // audio output volume of the engine.
   if (kNotSetOutputVolume != audio_output_volume_ &&
       !SetOutputVolume(audio_output_volume_)) {
     LOG(LS_WARNING) << "Failed to SetOutputVolume to "
                     << audio_output_volume_;
   }
 
   return initialized_;
 }
 
-bool ChannelManager::InitMediaEngine_w() {
-  ASSERT(worker_thread_ == rtc::Thread::Current());
-  return media_engine_->Init();
-}
-
 void ChannelManager::Terminate() {
   ASSERT(initialized_);
   if (!initialized_) {
     return;
   }
   worker_thread_->Invoke<void>(Bind(&ChannelManager::Terminate_w, this));
   initialized_ = false;
 }
 
 void ChannelManager::DestructorDeletes_w() {
@@ skipping 31 matching lines @@
     const AudioOptions& options) {
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(nullptr != media_controller);
   VoiceMediaChannel* media_channel = media_engine_->CreateChannel(
       media_controller->call_w(), media_controller->config(), options);
   if (!media_channel)
     return nullptr;
 
   VoiceChannel* voice_channel =
-      new VoiceChannel(worker_thread_, media_engine_.get(), media_channel,
-                       transport_controller, content_name, rtcp);
+      new VoiceChannel(worker_thread_, network_thread_, media_engine_.get(),
+                       media_channel, transport_controller, content_name, rtcp);
   if (!voice_channel->Init()) {
     delete voice_channel;
     return nullptr;
   }
   voice_channels_.push_back(voice_channel);
   return voice_channel;
 }
 
 void ChannelManager::DestroyVoiceChannel(VoiceChannel* voice_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyVoiceChannel");
@@ skipping 36 matching lines @@
     const VideoOptions& options) {
   ASSERT(initialized_);
   ASSERT(worker_thread_ == rtc::Thread::Current());
   ASSERT(nullptr != media_controller);
   VideoMediaChannel* media_channel = media_engine_->CreateVideoChannel(
       media_controller->call_w(), media_controller->config(), options);
   if (media_channel == NULL) {
     return NULL;
   }
 
-  VideoChannel* video_channel = new VideoChannel(
-      worker_thread_, media_channel, transport_controller, content_name, rtcp);
+  VideoChannel* video_channel =
+      new VideoChannel(worker_thread_, network_thread_, media_channel,
+                       transport_controller, content_name, rtcp);
   if (!video_channel->Init()) {
     delete video_channel;
     return NULL;
   }
   video_channels_.push_back(video_channel);
   return video_channel;
 }
 
 void ChannelManager::DestroyVideoChannel(VideoChannel* video_channel) {
   TRACE_EVENT0("webrtc", "ChannelManager::DestroyVideoChannel");
@@ skipping 36 matching lines @@
   // This is ok to alloc from a thread other than the worker thread.
   ASSERT(initialized_);
   DataMediaChannel* media_channel = data_media_engine_->CreateChannel(
       data_channel_type);
   if (!media_channel) {
     LOG(LS_WARNING) << "Failed to create data channel of type "
                     << data_channel_type;
     return NULL;
   }
 
-  DataChannel* data_channel = new DataChannel(
-      worker_thread_, media_channel, transport_controller, content_name, rtcp);
+  DataChannel* data_channel =
+      new DataChannel(worker_thread_, network_thread_, media_channel,
+                      transport_controller, content_name, rtcp);
   if (!data_channel->Init()) {
     LOG(LS_WARNING) << "Failed to init data channel.";
     delete data_channel;
     return NULL;
   }
   data_channels_.push_back(data_channel);
   return data_channel;
 }
 
 void ChannelManager::DestroyDataChannel(DataChannel* data_channel) {
@@ skipping 58 matching lines @@
   return worker_thread_->Invoke<bool>(
       Bind(&MediaEngineInterface::StartRtcEventLog, media_engine_.get(), file));
 }
 
 void ChannelManager::StopRtcEventLog() {
   worker_thread_->Invoke<void>(
       Bind(&MediaEngineInterface::StopRtcEventLog, media_engine_.get()));
 }
 
 }  // namespace cricket