Restore thread name consistency for webrtc/p2p/ .

webrtc/p2p/quic/quictransportchannel.cc

 /*
  *  Copyright 2016 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 108 matching lines @@
     return net::QUIC_SUCCESS;
   }
 };
 
 }  // namespace
 
 namespace cricket {
 
 QuicTransportChannel::QuicTransportChannel(TransportChannelImpl* channel)
     : TransportChannelImpl(channel->transport_name(), channel->component()),
-      worker_thread_(rtc::Thread::Current()),
+      network_thread_(rtc::Thread::Current()),
       channel_(channel),
-      helper_(worker_thread_) {
+      helper_(network_thread_) {
   channel_->SignalWritableState.connect(this,
                                         &QuicTransportChannel::OnWritableState);
   channel_->SignalReadPacket.connect(this, &QuicTransportChannel::OnReadPacket);
   channel_->SignalSentPacket.connect(this, &QuicTransportChannel::OnSentPacket);
   channel_->SignalReadyToSend.connect(this,
                                       &QuicTransportChannel::OnReadyToSend);
   channel_->SignalGatheringState.connect(
       this, &QuicTransportChannel::OnGatheringState);
   channel_->SignalCandidateGathered.connect(
       this, &QuicTransportChannel::OnCandidateGathered);
@@ skipping 124 matching lines @@
   LOG(LS_ERROR) << "Failed to send an invalid SRTP bypass packet using QUIC.";
   return -1;
 }
 
 // The state transition logic here is as follows:
 //     - Before the QUIC handshake is complete, the QUIC channel is unwritable.
 //     - When |channel_| goes writable we start the QUIC handshake.
 //     - Once the QUIC handshake completes, the state is that of the
 //       |channel_| again.
 void QuicTransportChannel::OnWritableState(TransportChannel* channel) {
-  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   ASSERT(channel == channel_.get());
   LOG_J(LS_VERBOSE, this)
       << "QuicTransportChannel: channel writable state changed to "
       << channel_->writable();
   switch (quic_state_) {
     case QUIC_TRANSPORT_NEW:
       // Start the QUIC handshake when |channel_| is writable.
       // This will fail if the SSL role or remote fingerprint are not set.
       // Otherwise failure could result from network or QUIC errors.
       MaybeStartQuic();
@@ skipping 13 matching lines @@
       }
       break;
     case QUIC_TRANSPORT_CLOSED:
       // TODO(mikescarlett): Allow the QUIC connection to be reset if it drops
       // due to a non-failure.
       break;
   }
 }
 
 void QuicTransportChannel::OnReceivingState(TransportChannel* channel) {
-  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   ASSERT(channel == channel_.get());
   LOG_J(LS_VERBOSE, this)
       << "QuicTransportChannel: channel receiving state changed to "
       << channel_->receiving();
   if (quic_state_ == QUIC_TRANSPORT_CONNECTED) {
     // Note: SignalReceivingState fired by set_receiving.
     set_receiving(channel_->receiving());
   }
 }
 
 void QuicTransportChannel::OnReadPacket(TransportChannel* channel,
                                         const char* data,
                                         size_t size,
                                         const rtc::PacketTime& packet_time,
                                         int flags) {
-  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   ASSERT(channel == channel_.get());
   ASSERT(flags == 0);
 
   switch (quic_state_) {
     case QUIC_TRANSPORT_NEW:
       // This would occur if other peer is ready to start QUIC but this peer
       // hasn't started QUIC.
       LOG_J(LS_INFO, this) << "Dropping packet received before QUIC started.";
       break;
     case QUIC_TRANSPORT_CONNECTING:
@@ skipping 16 matching lines @@
       }
       break;
     case QUIC_TRANSPORT_CLOSED:
       // This shouldn't be happening. Drop the packet.
       break;
   }
 }
 
 void QuicTransportChannel::OnSentPacket(TransportChannel* channel,
                                         const rtc::SentPacket& sent_packet) {
-  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   SignalSentPacket(this, sent_packet);
 }
 
 void QuicTransportChannel::OnReadyToSend(TransportChannel* channel) {
   if (writable()) {
     SignalReadyToSend(this);
   }
 }
 
 void QuicTransportChannel::OnGatheringState(TransportChannelImpl* channel) {
@@ skipping 125 matching lines @@
                                         quic_compressed_certs_cache_.get(),
                                         use_stateless_rejects_if_peer_supported,
                                         quic_.get());
     quic_->StartServerHandshake(crypto_stream);
     LOG_J(LS_INFO, this) << "QuicTransportChannel: Started server handshake.";
   }
   return true;
 }
 
 bool QuicTransportChannel::HandleQuicPacket(const char* data, size_t size) {
-  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(rtc::Thread::Current() == network_thread_);
   return quic_->OnReadPacket(data, size);
 }
 
 net::WriteResult QuicTransportChannel::WritePacket(
     const char* buffer,
     size_t buf_len,
     const net::IPAddress& self_address,
     const net::IPEndPoint& peer_address,
     net::PerPacketOptions* options) {
   // QUIC should never call this if IsWriteBlocked, but just in case...
@@ skipping 69 matching lines @@
     return quic_->CreateOutgoingDynamicStream(priority);
   }
   return nullptr;
 }
 
 void QuicTransportChannel::OnIncomingStream(ReliableQuicStream* stream) {
   SignalIncomingStream(stream);
 }
 
 }  // namespace cricket