Replace readable with receiving where receiving means receiving anything (stun ping, response or da…

webrtc/p2p/base/transport.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 88 matching lines @@
 
 Transport::Transport(rtc::Thread* signaling_thread,
                      rtc::Thread* worker_thread,
                      const std::string& content_name,
                      PortAllocator* allocator)
     : signaling_thread_(signaling_thread),
       worker_thread_(worker_thread),
       content_name_(content_name),
       allocator_(allocator),
       destroyed_(false),
-      readable_(TRANSPORT_STATE_NONE),
       writable_(TRANSPORT_STATE_NONE),
       receiving_(TRANSPORT_STATE_NONE),
       was_writable_(false),
       connect_requested_(false),
       ice_role_(ICEROLE_UNKNOWN),
       tiebreaker_(0),
       remote_ice_mode_(ICEMODE_FULL),
       channel_receiving_timeout_(-1) {
 }
 
@@ skipping 111 matching lines @@
   impl->SetReceivingTimeout(channel_receiving_timeout_);
   // TODO(ronghuawu): Change CreateChannel_w to be able to return error since
   // below Apply**Description_w calls can fail.
   if (local_description_)
     ApplyLocalTransportDescription_w(impl, NULL);
   if (remote_description_)
     ApplyRemoteTransportDescription_w(impl, NULL);
   if (local_description_ && remote_description_)
     ApplyNegotiatedTransportDescription_w(impl, NULL);
 
-  impl->SignalReadableState.connect(this, &Transport::OnChannelReadableState);
   impl->SignalWritableState.connect(this, &Transport::OnChannelWritableState);
   impl->SignalReceivingState.connect(this, &Transport::OnChannelReceivingState);
   impl->SignalRequestSignaling.connect(
       this, &Transport::OnChannelRequestSignaling);
   impl->SignalCandidateReady.connect(this, &Transport::OnChannelCandidateReady);
   impl->SignalRouteChange.connect(this, &Transport::OnChannelRouteChange);
   impl->SignalCandidatesAllocationDone.connect(
       this, &Transport::OnChannelCandidatesAllocationDone);
   impl->SignalRoleConflict.connect(this, &Transport::OnRoleConflict);
   impl->SignalConnectionRemoved.connect(
@@ skipping 234 matching lines @@
 
 void Transport::OnRemoteCandidate_w(const Candidate& candidate) {
   ASSERT(worker_thread()->IsCurrent());
   ChannelMap::iterator iter = channels_.find(candidate.component());
   // It's ok for a channel to go away while this message is in transit.
   if (iter != channels_.end()) {
     iter->second->OnCandidate(candidate);
   }
 }
 
-void Transport::OnChannelReadableState(TransportChannel* channel) {
-  ASSERT(worker_thread()->IsCurrent());
-  signaling_thread()->Post(this, MSG_READSTATE, NULL);
-}
-
-void Transport::OnChannelReadableState_s() {
-  ASSERT(signaling_thread()->IsCurrent());
-  TransportState readable = GetTransportState_s(TRANSPORT_READABLE_STATE);
-  if (readable_ != readable) {
-    readable_ = readable;
-    SignalReadableState(this);
-  }
-}
-
 void Transport::OnChannelWritableState(TransportChannel* channel) {
   ASSERT(worker_thread()->IsCurrent());
   signaling_thread()->Post(this, MSG_WRITESTATE, NULL);
 
   MaybeCompleted_w();
 }
 
 void Transport::OnChannelWritableState_s() {
   ASSERT(signaling_thread()->IsCurrent());
   TransportState writable = GetTransportState_s(TRANSPORT_WRITABLE_STATE);
@@ skipping 20 matching lines @@
 
 TransportState Transport::GetTransportState_s(TransportStateType state_type) {
   ASSERT(signaling_thread()->IsCurrent());
 
   rtc::CritScope cs(&crit_);
   bool any = false;
   bool all = !channels_.empty();
   for (const auto iter : channels_) {
     bool b = false;
     switch (state_type) {
-      case TRANSPORT_READABLE_STATE:
-        b = iter.second->readable();
-        break;
       case TRANSPORT_WRITABLE_STATE:
         b = iter.second->writable();
         break;
       case TRANSPORT_RECEIVING_STATE:
         b = iter.second->receiving();
         break;
       default:
         ASSERT(false);
     }
     any |= b;
@@ skipping 300 matching lines @@
       break;
     case MSG_ONREMOTECANDIDATE: {
         ChannelParams* params = static_cast<ChannelParams*>(msg->pdata);
         OnRemoteCandidate_w(*params->candidate);
         delete params;
       }
       break;
     case MSG_CONNECTING:
       OnConnecting_s();
       break;
-    case MSG_READSTATE:
-      OnChannelReadableState_s();
-      break;
     case MSG_WRITESTATE:
       OnChannelWritableState_s();
       break;
     case MSG_RECEIVINGSTATE:
       OnChannelReceivingState_s();
       break;
     case MSG_REQUESTSIGNALING:
       OnChannelRequestSignaling_s();
       break;
     case MSG_CANDIDATEREADY:
@@ skipping 14 matching lines @@
     case MSG_COMPLETED:
       SignalCompleted(this);
       break;
     case MSG_FAILED:
       SignalFailed(this);
       break;
   }
 }
 
 }  // namespace cricket