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

webrtc/p2p/base/dtlstransportchannel.cc

 /*
  *  Copyright 2011 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 79 matching lines @@
                                            Transport* transport,
                                            TransportChannelImpl* channel)
     : TransportChannelImpl(channel->content_name(), channel->component()),
       transport_(transport),
       worker_thread_(rtc::Thread::Current()),
       channel_(channel),
       downward_(NULL),
       dtls_state_(STATE_NONE),
       ssl_role_(rtc::SSL_CLIENT),
       ssl_max_version_(rtc::SSL_PROTOCOL_DTLS_10) {
+  channel_->SignalReadableState.connect(this,
+      &DtlsTransportChannelWrapper::OnReadableState);
   channel_->SignalWritableState.connect(this,
       &DtlsTransportChannelWrapper::OnWritableState);
   channel_->SignalReadPacket.connect(this,
       &DtlsTransportChannelWrapper::OnReadPacket);
   channel_->SignalReadyToSend.connect(this,
       &DtlsTransportChannelWrapper::OnReadyToSend);
   channel_->SignalRequestSignaling.connect(this,
       &DtlsTransportChannelWrapper::OnRequestSignaling);
   channel_->SignalCandidateReady.connect(this,
       &DtlsTransportChannelWrapper::OnCandidateReady);
@@ skipping 273 matching lines @@
       return -1;
   }
 
   return result;
 }
 
 // The state transition logic here is as follows:
 // (1) If we're not doing DTLS-SRTP, then the state is just the
 //     state of the underlying impl()
 // (2) If we're doing DTLS-SRTP:
-//     - Prior to the DTLS handshake, the state is neither receiving nor
+//     - Prior to the DTLS handshake, the state is neither readable or
 //       writable
 //     - When the impl goes writable for the first time we
 //       start the DTLS handshake
 //     - Once the DTLS handshake completes, the state is that of the
 //       impl again
+void DtlsTransportChannelWrapper::OnReadableState(TransportChannel* channel) {
+  ASSERT(rtc::Thread::Current() == worker_thread_);
+  ASSERT(channel == channel_);
+  LOG_J(LS_VERBOSE, this)
+      << "DTLSTransportChannelWrapper: channel readable state changed to "
+      << channel_->readable();
+
+  if (dtls_state_ == STATE_NONE || dtls_state_ == STATE_OPEN) {
+    set_readable(channel_->readable());
+    // Note: SignalReadableState fired by set_readable.
+  }
+}
+
 void DtlsTransportChannelWrapper::OnWritableState(TransportChannel* channel) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(channel == channel_);
   LOG_J(LS_VERBOSE, this)
       << "DTLSTransportChannelWrapper: channel writable state changed to "
       << channel_->writable();
 
   switch (dtls_state_) {
     case STATE_NONE:
     case STATE_OPEN:
@@ skipping 114 matching lines @@
                                               int sig, int err) {
   ASSERT(rtc::Thread::Current() == worker_thread_);
   ASSERT(dtls == dtls_.get());
   if (sig & rtc::SE_OPEN) {
     // This is the first time.
     LOG_J(LS_INFO, this) << "DTLS handshake complete.";
     if (dtls_->GetState() == rtc::SS_OPEN) {
       // The check for OPEN shouldn't be necessary but let's make
       // sure we don't accidentally frob the state if it's closed.
       dtls_state_ = STATE_OPEN;
+
+      set_readable(true);
       set_writable(true);
     }
   }
   if (sig & rtc::SE_READ) {
     char buf[kMaxDtlsPacketLen];
     size_t read;
     if (dtls_->Read(buf, sizeof(buf), &read, NULL) == rtc::SR_SUCCESS) {
       SignalReadPacket(this, buf, read, rtc::CreatePacketTime(0), 0);
     }
   }
   if (sig & rtc::SE_CLOSE) {
     ASSERT(sig == rtc::SE_CLOSE);  // SE_CLOSE should be by itself.
     if (!err) {
       LOG_J(LS_INFO, this) << "DTLS channel closed";
     } else {
       LOG_J(LS_INFO, this) << "DTLS channel error, code=" << err;
     }
+
+    set_readable(false);
     set_writable(false);
     dtls_state_ = STATE_CLOSED;
   }
 }
 
 bool DtlsTransportChannelWrapper::MaybeStartDtls() {
   if (channel_->writable()) {
     if (dtls_->StartSSLWithPeer()) {
       LOG_J(LS_ERROR, this) << "Couldn't start DTLS handshake";
       dtls_state_ = STATE_CLOSED;
@@ skipping 61 matching lines @@
   SignalRouteChange(this, candidate);
 }
 
 void DtlsTransportChannelWrapper::OnConnectionRemoved(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
   SignalConnectionRemoved(this);
 }
 
 }  // namespace cricket