Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

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.
  */
 
 #include <memory>
 #include <utility>
 
 #include "webrtc/p2p/base/dtlstransportchannel.h"
 
 #include "webrtc/p2p/base/common.h"
-#include "webrtc/p2p/base/packettransportinterface.h"
+#include "webrtc/p2p/base/packettransportinternal.h"
 #include "webrtc/base/buffer.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/dscp.h"
 #include "webrtc/base/messagequeue.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stream.h"
 #include "webrtc/base/thread.h"
 
 namespace cricket {
 
@@ skipping 386 matching lines @@
 // 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
 //       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 DtlsTransport::OnWritableState(rtc::PacketTransportInterface* transport) {
+void DtlsTransport::OnWritableState(rtc::PacketTransportInternal* transport) {
   RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   RTC_DCHECK(transport == ice_transport_);
   LOG_J(LS_VERBOSE, this)
       << "DTLSTransportChannelWrapper: ice_transport writable state changed to "
       << ice_transport_->writable();
 
   if (!dtls_active_) {
     // Not doing DTLS.
     // Note: SignalWritableState fired by set_writable.
     set_writable(ice_transport_->writable());
@@ skipping 11 matching lines @@
     case DTLS_TRANSPORT_CONNECTING:
       // Do nothing.
       break;
     case DTLS_TRANSPORT_FAILED:
     case DTLS_TRANSPORT_CLOSED:
       // Should not happen. Do nothing.
       break;
   }
 }
 
-void DtlsTransport::OnReceivingState(rtc::PacketTransportInterface* transport) {
+void DtlsTransport::OnReceivingState(rtc::PacketTransportInternal* transport) {
   RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   RTC_DCHECK(transport == ice_transport_);
   LOG_J(LS_VERBOSE, this) << "DTLSTransportChannelWrapper: ice_transport "
                              "receiving state changed to "
                           << ice_transport_->receiving();
   if (!dtls_active_ || dtls_state() == DTLS_TRANSPORT_CONNECTED) {
     // Note: SignalReceivingState fired by set_receiving.
     set_receiving(ice_transport_->receiving());
   }
 }
 
-void DtlsTransport::OnReadPacket(rtc::PacketTransportInterface* transport,
+void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
                                  const char* data,
                                  size_t size,
                                  const rtc::PacketTime& packet_time,
                                  int flags) {
   RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   RTC_DCHECK(transport == ice_transport_);
   RTC_DCHECK(flags == 0);
 
   if (!dtls_active_) {
     // Not doing DTLS.
@@ skipping 57 matching lines @@
         SignalReadPacket(this, data, size, packet_time, PF_SRTP_BYPASS);
       }
       break;
     case DTLS_TRANSPORT_FAILED:
     case DTLS_TRANSPORT_CLOSED:
       // This shouldn't be happening. Drop the packet.
       break;
   }
 }
 
-void DtlsTransport::OnSentPacket(rtc::PacketTransportInterface* transport,
+void DtlsTransport::OnSentPacket(rtc::PacketTransportInternal* transport,
                                  const rtc::SentPacket& sent_packet) {
   RTC_DCHECK(rtc::Thread::Current() == network_thread_);
 
   SignalSentPacket(this, sent_packet);
 }
 
-void DtlsTransport::OnReadyToSend(rtc::PacketTransportInterface* transport) {
+void DtlsTransport::OnReadyToSend(rtc::PacketTransportInternal* transport) {
   if (writable()) {
     SignalReadyToSend(this);
   }
 }
 
 void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
   RTC_DCHECK(rtc::Thread::Current() == network_thread_);
   RTC_DCHECK(dtls == dtls_.get());
   if (sig & rtc::SE_OPEN) {
     // This is the first time.
@@ skipping 123 matching lines @@
                           << state;
   dtls_state_ = state;
   SignalDtlsState(this, state);
 }
 
 void DtlsTransport::OnDtlsHandshakeError(rtc::SSLHandshakeError error) {
   SignalDtlsHandshakeError(error);
 }
 
 }  // namespace cricket