Revert of TransportController refactoring.

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 69 matching lines @@
   // We force a read event here to ensure that we don't overflow our queue.
   bool ret = packets_.WriteBack(data, size, NULL);
   RTC_CHECK(ret) << "Failed to write packet to queue.";
   if (ret) {
     SignalEvent(this, rtc::SE_READ, 0);
   }
   return ret;
 }
 
 DtlsTransportChannelWrapper::DtlsTransportChannelWrapper(
-    Transport* transport,
-    TransportChannelImpl* channel)
-    : TransportChannelImpl(channel->transport_name(), channel->component()),
+                                           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_->SignalWritableState.connect(this,
       &DtlsTransportChannelWrapper::OnWritableState);
   channel_->SignalReadPacket.connect(this,
       &DtlsTransportChannelWrapper::OnReadPacket);
   channel_->SignalReadyToSend.connect(this,
       &DtlsTransportChannelWrapper::OnReadyToSend);
-  channel_->SignalGatheringState.connect(
-      this, &DtlsTransportChannelWrapper::OnGatheringState);
-  channel_->SignalCandidateGathered.connect(
-      this, &DtlsTransportChannelWrapper::OnCandidateGathered);
+  channel_->SignalRequestSignaling.connect(this,
+      &DtlsTransportChannelWrapper::OnRequestSignaling);
+  channel_->SignalCandidateReady.connect(this,
+      &DtlsTransportChannelWrapper::OnCandidateReady);
+  channel_->SignalCandidatesAllocationDone.connect(this,
+      &DtlsTransportChannelWrapper::OnCandidatesAllocationDone);
   channel_->SignalRoleConflict.connect(this,
       &DtlsTransportChannelWrapper::OnRoleConflict);
   channel_->SignalRouteChange.connect(this,
       &DtlsTransportChannelWrapper::OnRouteChange);
   channel_->SignalConnectionRemoved.connect(this,
       &DtlsTransportChannelWrapper::OnConnectionRemoved);
   channel_->SignalReceivingState.connect(this,
       &DtlsTransportChannelWrapper::OnReceivingState);
 }
 
@@ skipping 82 matching lines @@
   rtc::Buffer remote_fingerprint_value(digest, digest_len);
 
   if (dtls_state_ != STATE_NONE &&
       remote_fingerprint_value_ == remote_fingerprint_value &&
       !digest_alg.empty()) {
     // This may happen during renegotiation.
     LOG_J(LS_INFO, this) << "Ignoring identical remote DTLS fingerprint";
     return true;
   }
 
-  // Allow SetRemoteFingerprint with a NULL digest even if SetLocalCertificate
+  // Allow SetRemoteFingerprint with a NULL digest even if SetLocalIdentity
   // hasn't been called.
   if (dtls_state_ > STATE_OFFERED ||
       (dtls_state_ == STATE_NONE && !digest_alg.empty())) {
     LOG_J(LS_ERROR, this) << "Can't set DTLS remote settings in this state.";
     return false;
   }
 
   if (digest_alg.empty()) {
     LOG_J(LS_INFO, this) << "Other side didn't support DTLS.";
     dtls_state_ = STATE_NONE;
@@ skipping 359 matching lines @@
 
     tmp_data += record_len + kDtlsRecordHeaderLen;
     tmp_size -= record_len + kDtlsRecordHeaderLen;
   }
 
   // Looks good. Pass to the SIC which ends up being passed to
   // the DTLS stack.
   return downward_->OnPacketReceived(data, size);
 }
 
-void DtlsTransportChannelWrapper::OnGatheringState(
+void DtlsTransportChannelWrapper::OnRequestSignaling(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
-  SignalGatheringState(this);
+  SignalRequestSignaling(this);
 }
 
-void DtlsTransportChannelWrapper::OnCandidateGathered(
-    TransportChannelImpl* channel,
-    const Candidate& c) {
+void DtlsTransportChannelWrapper::OnCandidateReady(
+    TransportChannelImpl* channel, const Candidate& c) {
   ASSERT(channel == channel_);
-  SignalCandidateGathered(this, c);
+  SignalCandidateReady(this, c);
+}
+
+void DtlsTransportChannelWrapper::OnCandidatesAllocationDone(
+    TransportChannelImpl* channel) {
+  ASSERT(channel == channel_);
+  SignalCandidatesAllocationDone(this);
 }
 
 void DtlsTransportChannelWrapper::OnRoleConflict(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
   SignalRoleConflict(this);
 }
 
 void DtlsTransportChannelWrapper::OnRouteChange(
     TransportChannel* channel, const Candidate& candidate) {
   ASSERT(channel == channel_);
   SignalRouteChange(this, candidate);
 }
 
 void DtlsTransportChannelWrapper::OnConnectionRemoved(
     TransportChannelImpl* channel) {
   ASSERT(channel == channel_);
   SignalConnectionRemoved(this);
 }
 
 }  // namespace cricket