1 files changed, 54 insertions, 48 deletions

diff --git a/p2p/base/dtls_transport.cc b/p2p/base/dtls_transport.cc
index 99ee0f1a16..76b94a8d79 100644
--- a/p2p/base/dtls_transport.cc
+++ b/p2p/base/dtls_transport.cc
@@ -15,6 +15,7 @@
 #include <utility>
 
 #include "absl/memory/memory.h"
+#include "api/dtls_transport_interface.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "logging/rtc_event_log/events/rtc_event_dtls_transport_state.h"
 #include "logging/rtc_event_log/events/rtc_event_dtls_writable_state.h"
@@ -148,7 +149,7 @@ DtlsTransport::DtlsTransport(IceTransportInternal* ice_transport,
 
 DtlsTransport::~DtlsTransport() = default;
 
-DtlsTransportState DtlsTransport::dtls_state() const {
+webrtc::DtlsTransportState DtlsTransport::dtls_state() const {
   return dtls_state_;
 }
 
@@ -218,7 +219,7 @@ bool DtlsTransport::GetDtlsRole(rtc::SSLRole* role) const {
 }
 
 bool DtlsTransport::GetSslCipherSuite(int* cipher) {
-  if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
     return false;
   }
 
@@ -276,7 +277,7 @@ bool DtlsTransport::SetRemoteFingerprint(const std::string& digest_alg,
             remote_fingerprint_value_.size(), &err)) {
       RTC_LOG(LS_ERROR) << ToString()
                         << ": Couldn't set DTLS certificate digest.";
-      set_dtls_state(DTLS_TRANSPORT_FAILED);
+      set_dtls_state(webrtc::DtlsTransportState::kFailed);
       // If the error is "verification failed", don't return false, because
       // this means the fingerprint was formatted correctly but didn't match
       // the certificate from the DTLS handshake. Thus the DTLS state should go
@@ -290,12 +291,12 @@ bool DtlsTransport::SetRemoteFingerprint(const std::string& digest_alg,
   // create a new one, resetting our state.
   if (dtls_ && fingerprint_changing) {
     dtls_.reset(nullptr);
-    set_dtls_state(DTLS_TRANSPORT_NEW);
+    set_dtls_state(webrtc::DtlsTransportState::kNew);
     set_writable(false);
   }
 
   if (!SetupDtls()) {
-    set_dtls_state(DTLS_TRANSPORT_FAILED);
+    set_dtls_state(webrtc::DtlsTransportState::kFailed);
     return false;
   }
 
@@ -373,7 +374,7 @@ bool DtlsTransport::SetupDtls() {
 }
 
 bool DtlsTransport::GetSrtpCryptoSuite(int* cipher) {
-  if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
     return false;
   }
 
@@ -381,7 +382,7 @@ bool DtlsTransport::GetSrtpCryptoSuite(int* cipher) {
 }
 
 bool DtlsTransport::GetSslVersionBytes(int* version) const {
-  if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
     return false;
   }
 
@@ -399,14 +400,14 @@ int DtlsTransport::SendPacket(const char* data,
   }
 
   switch (dtls_state()) {
-    case DTLS_TRANSPORT_NEW:
+    case webrtc::DtlsTransportState::kNew:
       // Can't send data until the connection is active.
       // TODO(ekr@rtfm.com): assert here if dtls_ is NULL?
       return -1;
-    case DTLS_TRANSPORT_CONNECTING:
+    case webrtc::DtlsTransportState::kConnecting:
       // Can't send data until the connection is active.
       return -1;
-    case DTLS_TRANSPORT_CONNECTED:
+    case webrtc::DtlsTransportState::kConnected:
       if (flags & PF_SRTP_BYPASS) {
         RTC_DCHECK(!srtp_ciphers_.empty());
         if (!IsRtpPacket(data, size)) {
@@ -419,17 +420,17 @@ int DtlsTransport::SendPacket(const char* data,
                    ? static_cast<int>(size)
                    : -1;
       }
-    case DTLS_TRANSPORT_FAILED:
+    case webrtc::DtlsTransportState::kFailed:
       // Can't send anything when we're failed.
-      RTC_LOG(LS_ERROR)
-          << ToString()
-          << ": Couldn't send packet due to DTLS_TRANSPORT_FAILED.";
+      RTC_LOG(LS_ERROR) << ToString()
+                        << ": Couldn't send packet due to "
+                           "webrtc::DtlsTransportState::kFailed.";
       return -1;
-    case DTLS_TRANSPORT_CLOSED:
+    case webrtc::DtlsTransportState::kClosed:
       // Can't send anything when we're closed.
-      RTC_LOG(LS_ERROR)
-          << ToString()
-          << ": Couldn't send packet due to DTLS_TRANSPORT_CLOSED.";
+      RTC_LOG(LS_ERROR) << ToString()
+                        << ": Couldn't send packet due to "
+                           "webrtc::DtlsTransportState::kClosed.";
       return -1;
     default:
       RTC_NOTREACHED();
@@ -508,27 +509,30 @@ void DtlsTransport::OnWritableState(rtc::PacketTransportInternal* transport) {
   }
 
   switch (dtls_state()) {
-    case DTLS_TRANSPORT_NEW:
+    case webrtc::DtlsTransportState::kNew:
       MaybeStartDtls();
       break;
-    case DTLS_TRANSPORT_CONNECTED:
+    case webrtc::DtlsTransportState::kConnected:
       // Note: SignalWritableState fired by set_writable.
       set_writable(ice_transport_->writable());
       break;
-    case DTLS_TRANSPORT_CONNECTING:
+    case webrtc::DtlsTransportState::kConnecting:
       // Do nothing.
       break;
-    case DTLS_TRANSPORT_FAILED:
+    case webrtc::DtlsTransportState::kFailed:
       // Should not happen. Do nothing.
-      RTC_LOG(LS_ERROR)
-          << ToString()
-          << ": OnWritableState() called in state DTLS_TRANSPORT_FAILED.";
+      RTC_LOG(LS_ERROR) << ToString()
+                        << ": OnWritableState() called in state "
+                           "webrtc::DtlsTransportState::kFailed.";
       break;
-    case DTLS_TRANSPORT_CLOSED:
+    case webrtc::DtlsTransportState::kClosed:
       // Should not happen. Do nothing.
-      RTC_LOG(LS_ERROR)
-          << ToString()
-          << ": OnWritableState() called in state DTLS_TRANSPORT_CLOSED.";
+      RTC_LOG(LS_ERROR) << ToString()
+                        << ": OnWritableState() called in state "
+                           "webrtc::DtlsTransportState::kClosed.";
+      break;
+    case webrtc::DtlsTransportState::kNumValues:
+      RTC_NOTREACHED();
       break;
   }
 }
@@ -540,7 +544,7 @@ void DtlsTransport::OnReceivingState(rtc::PacketTransportInternal* transport) {
                       << ": ice_transport "
                          "receiving state changed to "
                       << ice_transport_->receiving();
-  if (!dtls_active_ || dtls_state() == DTLS_TRANSPORT_CONNECTED) {
+  if (!dtls_active_ || dtls_state() == webrtc::DtlsTransportState::kConnected) {
     // Note: SignalReceivingState fired by set_receiving.
     set_receiving(ice_transport_->receiving());
   }
@@ -562,7 +566,7 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
   }
 
   switch (dtls_state()) {
-    case DTLS_TRANSPORT_NEW:
+    case webrtc::DtlsTransportState::kNew:
       if (dtls_) {
         RTC_LOG(LS_INFO) << ToString()
                          << ": Packet received before DTLS started.";
@@ -591,8 +595,8 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
       }
       break;
 
-    case DTLS_TRANSPORT_CONNECTING:
-    case DTLS_TRANSPORT_CONNECTED:
+    case webrtc::DtlsTransportState::kConnecting:
+    case webrtc::DtlsTransportState::kConnected:
       // We should only get DTLS or SRTP packets; STUN's already been demuxed.
       // Is this potentially a DTLS packet?
       if (IsDtlsPacket(data, size)) {
@@ -602,7 +606,7 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
         }
       } else {
         // Not a DTLS packet; our handshake should be complete by now.
-        if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+        if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
           RTC_LOG(LS_ERROR) << ToString()
                             << ": Received non-DTLS packet before DTLS "
                                "complete.";
@@ -623,8 +627,9 @@ void DtlsTransport::OnReadPacket(rtc::PacketTransportInternal* transport,
         SignalReadPacket(this, data, size, packet_time_us, PF_SRTP_BYPASS);
       }
       break;
-    case DTLS_TRANSPORT_FAILED:
-    case DTLS_TRANSPORT_CLOSED:
+    case webrtc::DtlsTransportState::kFailed:
+    case webrtc::DtlsTransportState::kClosed:
+    case webrtc::DtlsTransportState::kNumValues:
       // This shouldn't be happening. Drop the packet.
       break;
   }
@@ -652,7 +657,7 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
     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.
-      set_dtls_state(DTLS_TRANSPORT_CONNECTED);
+      set_dtls_state(webrtc::DtlsTransportState::kConnected);
       set_writable(true);
     }
   }
@@ -671,7 +676,7 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
         // Remote peer shut down the association with no error.
         RTC_LOG(LS_INFO) << ToString() << ": DTLS transport closed by remote";
         set_writable(false);
-        set_dtls_state(DTLS_TRANSPORT_CLOSED);
+        set_dtls_state(webrtc::DtlsTransportState::kClosed);
         SignalClosed(this);
       } else if (ret == rtc::SR_ERROR) {
         // Remote peer shut down the association with an error.
@@ -680,7 +685,7 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
             << ": Closed by remote with DTLS transport error, code="
             << read_error;
         set_writable(false);
-        set_dtls_state(DTLS_TRANSPORT_FAILED);
+        set_dtls_state(webrtc::DtlsTransportState::kFailed);
         SignalClosed(this);
       }
     } while (ret == rtc::SR_SUCCESS);
@@ -690,10 +695,10 @@ void DtlsTransport::OnDtlsEvent(rtc::StreamInterface* dtls, int sig, int err) {
     set_writable(false);
     if (!err) {
       RTC_LOG(LS_INFO) << ToString() << ": DTLS transport closed";
-      set_dtls_state(DTLS_TRANSPORT_CLOSED);
+      set_dtls_state(webrtc::DtlsTransportState::kClosed);
     } else {
       RTC_LOG(LS_INFO) << ToString() << ": DTLS transport error, code=" << err;
-      set_dtls_state(DTLS_TRANSPORT_FAILED);
+      set_dtls_state(webrtc::DtlsTransportState::kFailed);
     }
   }
 }
@@ -717,11 +722,11 @@ void DtlsTransport::MaybeStartDtls() {
       // configuration and therefore are our fault.
       RTC_NOTREACHED() << "StartSSL failed.";
       RTC_LOG(LS_ERROR) << ToString() << ": Couldn't start DTLS handshake";
-      set_dtls_state(DTLS_TRANSPORT_FAILED);
+      set_dtls_state(webrtc::DtlsTransportState::kFailed);
       return;
     }
     RTC_LOG(LS_INFO) << ToString() << ": DtlsTransport: Started DTLS handshake";
-    set_dtls_state(DTLS_TRANSPORT_CONNECTING);
+    set_dtls_state(webrtc::DtlsTransportState::kConnecting);
     // Now that the handshake has started, we can process a cached ClientHello
     // (if one exists).
     if (cached_client_hello_.size()) {
@@ -789,16 +794,17 @@ void DtlsTransport::set_writable(bool writable) {
   SignalWritableState(this);
 }
 
-void DtlsTransport::set_dtls_state(DtlsTransportState state) {
+void DtlsTransport::set_dtls_state(webrtc::DtlsTransportState state) {
   if (dtls_state_ == state) {
     return;
   }
   if (event_log_) {
-    event_log_->Log(std::make_unique<webrtc::RtcEventDtlsTransportState>(
-        ConvertDtlsTransportState(state)));
+    event_log_->Log(
+        std::make_unique<webrtc::RtcEventDtlsTransportState>(state));
   }
-  RTC_LOG(LS_VERBOSE) << ToString() << ": set_dtls_state from:" << dtls_state_
-                      << " to " << state;
+  RTC_LOG(LS_VERBOSE) << ToString() << ": set_dtls_state from:"
+                      << static_cast<int>(dtls_state_) << " to "
+                      << static_cast<int>(state);
   dtls_state_ = state;
   SendDtlsState(this, state);
 }