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

webrtc/p2p/base/transportchannelproxy.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 37 matching lines @@
 
   // Destroy any existing impl_.
   if (impl_) {
     impl_->GetTransport()->DestroyChannel(impl_->component());
   }
 
   // Adopt the supplied impl, and connect to its signals.
   impl_ = impl;
 
   if (impl_) {
-    impl_->SignalReadableState.connect(
-        this, &TransportChannelProxy::OnReadableState);
     impl_->SignalWritableState.connect(
         this, &TransportChannelProxy::OnWritableState);
+    impl_->SignalReceivingState.connect(
+        this, &TransportChannelProxy::OnReceivingState);
     impl_->SignalReadPacket.connect(
         this, &TransportChannelProxy::OnReadPacket);
     impl_->SignalReadyToSend.connect(
         this, &TransportChannelProxy::OnReadyToSend);
     impl_->SignalRouteChange.connect(
         this, &TransportChannelProxy::OnRouteChange);
     for (const auto& pair : options_) {
       impl_->SetOption(pair.first, pair.second);
     }
 
@@ skipping 150 matching lines @@
 }
 
 IceRole TransportChannelProxy::GetIceRole() const {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   if (!impl_) {
     return ICEROLE_UNKNOWN;
   }
   return impl_->GetIceRole();
 }
 
-void TransportChannelProxy::OnReadableState(TransportChannel* channel) {
-  ASSERT(rtc::Thread::Current() == worker_thread_);
-  ASSERT(channel == impl_);
-  set_readable(impl_->readable());
-  // Note: SignalReadableState fired by set_readable.
-}
-
 void TransportChannelProxy::OnWritableState(TransportChannel* channel) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   set_writable(impl_->writable());
-  // Note: SignalWritableState fired by set_readable.
+  // Note: SignalWritableState fired by set_writable.
+}
+
+void TransportChannelProxy::OnReceivingState(TransportChannel* channel) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(channel == impl_);
+  set_receiving(impl_->receiving());
+  // Note: SignalReceivingState fired by set_receiving.
 }
 
 void TransportChannelProxy::OnReadPacket(
     TransportChannel* channel, const char* data, size_t size,
     const rtc::PacketTime& packet_time, int flags) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   SignalReadPacket(this, data, size, packet_time, flags);
 }
 
 void TransportChannelProxy::OnReadyToSend(TransportChannel* channel) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   SignalReadyToSend(this);
 }
 
 void TransportChannelProxy::OnRouteChange(TransportChannel* channel,
                                           const Candidate& candidate) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == impl_);
   SignalRouteChange(this, candidate);
 }
 
 void TransportChannelProxy::OnMessage(rtc::Message* msg) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   if (msg->message_id == MSG_UPDATESTATE) {
-     // If impl_ is already readable or writable, push up those signals.
-     set_readable(impl_ ? impl_->readable() : false);
-     set_writable(impl_ ? impl_->writable() : false);
+    // If impl_ is already receiving or writable, push up those signals.
+    set_writable(impl_ ? impl_->writable() : false);
+    set_receiving(impl_ ? impl_->receiving() : false);
   }
 }
 
 }  // namespace cricket