Renames TransportController worker_thread to network_thread.

webrtc/pc/channel.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 155 matching lines @@
       dtls_keyed_(false),
       secure_required_(false),
       rtp_abs_sendtime_extn_id_(-1),
 
       media_channel_(media_channel),
       enabled_(false),
       local_content_direction_(MD_INACTIVE),
       remote_content_direction_(MD_INACTIVE) {
   ASSERT(worker_thread_ == rtc::Thread::Current());
   if (transport_controller) {
-    RTC_DCHECK_EQ(network_thread, transport_controller->worker_thread());
+    RTC_DCHECK_EQ(network_thread, transport_controller->network_thread());
   }
   LOG(LS_INFO) << "Created channel for " << content_name;
 }
 
 BaseChannel::~BaseChannel() {
   TRACE_EVENT0("webrtc", "BaseChannel::~BaseChannel");
   ASSERT(worker_thread_ == rtc::Thread::Current());
   Deinit();
   StopConnectionMonitor();
   // Send any outstanding RTCP packets.
   network_thread_->Invoke<void>(Bind(&BaseChannel::FlushRtcpMessages_n, this));
   // Eats any outstanding messages or packets.
   worker_thread_->Clear(&invoker_);
   worker_thread_->Clear(this);
   // We must destroy the media channel before the transport channel, otherwise
   // the media channel may try to send on the dead transport channel. NULLing
   // is not an effective strategy since the sends will come on another thread.
   delete media_channel_;
   // Note that we don't just call SetTransportChannel_n(nullptr) because that
   // would call a pure virtual method which we can't do from a destructor.
   network_thread_->Invoke<void>(Bind(&BaseChannel::DeinitNetwork_n, this));
   LOG(LS_INFO) << "Destroyed channel";
 }
 
 void BaseChannel::DeinitNetwork_n() {
   if (transport_channel_) {
     DisconnectFromTransportChannel(transport_channel_);
-    transport_controller_->DestroyTransportChannel_w(
+    transport_controller_->DestroyTransportChannel_n(
         transport_name_, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   }
   if (rtcp_transport_channel_) {
     DisconnectFromTransportChannel(rtcp_transport_channel_);
-    transport_controller_->DestroyTransportChannel_w(
+    transport_controller_->DestroyTransportChannel_n(
         transport_name_, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
   network_thread_->Clear(this);
 }
 
 bool BaseChannel::Init_w() {
   if (!network_thread_->Invoke<bool>(Bind(&BaseChannel::InitNetwork_n, this))) {
     return false;
   }
 
@@ skipping 46 matching lines @@
     // DTLS-SRTP when the writable_ becomes true again.
     writable_ = false;
     srtp_filter_.ResetParams();
   }
 
   // TODO(guoweis): Remove this grossness when we remove non-muxed RTCP.
   if (rtcp_transport_enabled()) {
     LOG(LS_INFO) << "Create RTCP TransportChannel for " << content_name()
                  << " on " << transport_name << " transport ";
     SetRtcpTransportChannel_n(
-        transport_controller_->CreateTransportChannel_w(
+        transport_controller_->CreateTransportChannel_n(
             transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTCP),
         false /* update_writablity */);
     if (!rtcp_transport_channel_) {
       return false;
     }
   }
 
   // We're not updating the writablity during the transition state.
-  SetTransportChannel_n(transport_controller_->CreateTransportChannel_w(
+  SetTransportChannel_n(transport_controller_->CreateTransportChannel_n(
       transport_name, cricket::ICE_CANDIDATE_COMPONENT_RTP));
   if (!transport_channel_) {
     return false;
   }
 
   // TODO(guoweis): Remove this grossness when we remove non-muxed RTCP.
   if (rtcp_transport_enabled()) {
     // We can only update the RTCP ready to send after set_transport_channel has
     // handled channel writability.
     SetReadyToSend(
         true, rtcp_transport_channel_ && rtcp_transport_channel_->writable());
   }
   transport_name_ = transport_name;
   return true;
 }
 
 void BaseChannel::SetTransportChannel_n(TransportChannel* new_tc) {
   RTC_DCHECK(network_thread_->IsCurrent());
 
   TransportChannel* old_tc = transport_channel_;
   if (!old_tc && !new_tc) {
     // Nothing to do
     return;
   }
   ASSERT(old_tc != new_tc);
 
   if (old_tc) {
     DisconnectFromTransportChannel(old_tc);
-    transport_controller_->DestroyTransportChannel_w(
+    transport_controller_->DestroyTransportChannel_n(
         transport_name_, cricket::ICE_CANDIDATE_COMPONENT_RTP);
   }
 
   transport_channel_ = new_tc;
 
   if (new_tc) {
     ConnectToTransportChannel(new_tc);
     for (const auto& pair : socket_options_) {
       new_tc->SetOption(pair.first, pair.second);
     }
@@ skipping 11 matching lines @@
 
   TransportChannel* old_tc = rtcp_transport_channel_;
   if (!old_tc && !new_tc) {
     // Nothing to do
     return;
   }
   ASSERT(old_tc != new_tc);
 
   if (old_tc) {
     DisconnectFromTransportChannel(old_tc);
-    transport_controller_->DestroyTransportChannel_w(
+    transport_controller_->DestroyTransportChannel_n(
         transport_name_, cricket::ICE_CANDIDATE_COMPONENT_RTCP);
   }
 
   rtcp_transport_channel_ = new_tc;
 
   if (new_tc) {
     RTC_CHECK(!(ShouldSetupDtlsSrtp_n() && srtp_filter_.IsActive()))
         << "Setting RTCP for DTLS/SRTP after SrtpFilter is active "
         << "should never happen.";
     ConnectToTransportChannel(new_tc);
@@ skipping 1966 matching lines @@
   return data_channel_type_ == DCT_RTP && BaseChannel::ShouldSetupDtlsSrtp_n();
 }
 
 void DataChannel::OnStreamClosedRemotely(uint32_t sid) {
   rtc::TypedMessageData<uint32_t>* message =
       new rtc::TypedMessageData<uint32_t>(sid);
   signaling_thread()->Post(this, MSG_STREAMCLOSEDREMOTELY, message);
 }
 
 }  // namespace cricket