Revert of 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.
  */
 
 #include "webrtc/p2p/base/transport.h"
 
 #include "webrtc/p2p/base/candidate.h"
 #include "webrtc/p2p/base/constants.h"
 #include "webrtc/p2p/base/port.h"
 #include "webrtc/p2p/base/transportchannelimpl.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 
 namespace cricket {
 
 using rtc::Bind;
 
 enum {
   MSG_ONSIGNALINGREADY = 1,
   MSG_ONREMOTECANDIDATE,
+  MSG_READSTATE,
   MSG_WRITESTATE,
   MSG_REQUESTSIGNALING,
   MSG_CANDIDATEREADY,
   MSG_ROUTECHANGE,
   MSG_CONNECTING,
   MSG_CANDIDATEALLOCATIONCOMPLETE,
   MSG_ROLECONFLICT,
   MSG_COMPLETED,
   MSG_FAILED,
   MSG_RECEIVINGSTATE,
@@ skipping 192 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