diff --git a/p2p/base/dtls_transport.cc b/p2p/base/dtls_transport.cc
index 99ee0f1..76b94a8 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() = default;
 
-DtlsTransportState DtlsTransport::dtls_state() const {
+webrtc::DtlsTransportState DtlsTransport::dtls_state() const {
   return dtls_state_;
 }
 
@@ -218,7 +219,7 @@
 }
 
 bool DtlsTransport::GetSslCipherSuite(int* cipher) {
-  if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
     return false;
   }
 
@@ -276,7 +277,7 @@
             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 @@
   // 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::GetSrtpCryptoSuite(int* cipher) {
-  if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
     return false;
   }
 
@@ -381,7 +382,7 @@
 }
 
 bool DtlsTransport::GetSslVersionBytes(int* version) const {
-  if (dtls_state() != DTLS_TRANSPORT_CONNECTED) {
+  if (dtls_state() != webrtc::DtlsTransportState::kConnected) {
     return false;
   }
 
@@ -399,14 +400,14 @@
   }
 
   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 @@
                    ? 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 @@
   }
 
   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 @@
                       << ": 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 @@
   }
 
   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 @@
       }
       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 @@
         }
       } 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 @@
         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 @@
     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 @@
         // 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 @@
             << ": 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 @@
     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 @@
       // 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 @@
   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);
 }
diff --git a/p2p/base/dtls_transport.h b/p2p/base/dtls_transport.h
index f37e468..0296a74 100644
--- a/p2p/base/dtls_transport.h
+++ b/p2p/base/dtls_transport.h
@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "api/crypto/crypto_options.h"
+#include "api/dtls_transport_interface.h"
 #include "api/sequence_checker.h"
 #include "p2p/base/dtls_transport_internal.h"
 #include "p2p/base/ice_transport_internal.h"
@@ -109,7 +110,7 @@
 
   ~DtlsTransport() override;
 
-  DtlsTransportState dtls_state() const override;
+  webrtc::DtlsTransportState dtls_state() const override;
   const std::string& transport_name() const override;
   int component() const override;
 
@@ -219,12 +220,12 @@
   void set_receiving(bool receiving);
   void set_writable(bool writable);
   // Sets the DTLS state, signaling if necessary.
-  void set_dtls_state(DtlsTransportState state);
+  void set_dtls_state(webrtc::DtlsTransportState state);
 
   webrtc::SequenceChecker thread_checker_;
 
   const int component_;
-  DtlsTransportState dtls_state_ = DTLS_TRANSPORT_NEW;
+  webrtc::DtlsTransportState dtls_state_ = webrtc::DtlsTransportState::kNew;
   // Underlying ice_transport, not owned by this class.
   IceTransportInternal* const ice_transport_;
   std::unique_ptr<rtc::SSLStreamAdapter> dtls_;  // The DTLS stream
diff --git a/p2p/base/dtls_transport_internal.cc b/p2p/base/dtls_transport_internal.cc
index dd23b1b..6997dbc 100644
--- a/p2p/base/dtls_transport_internal.cc
+++ b/p2p/base/dtls_transport_internal.cc
@@ -16,22 +16,4 @@
 
 DtlsTransportInternal::~DtlsTransportInternal() = default;
 
-webrtc::DtlsTransportState ConvertDtlsTransportState(
-    cricket::DtlsTransportState cricket_state) {
-  switch (cricket_state) {
-    case DtlsTransportState::DTLS_TRANSPORT_NEW:
-      return webrtc::DtlsTransportState::kNew;
-    case DtlsTransportState::DTLS_TRANSPORT_CONNECTING:
-      return webrtc::DtlsTransportState::kConnecting;
-    case DtlsTransportState::DTLS_TRANSPORT_CONNECTED:
-      return webrtc::DtlsTransportState::kConnected;
-    case DtlsTransportState::DTLS_TRANSPORT_CLOSED:
-      return webrtc::DtlsTransportState::kClosed;
-    case DtlsTransportState::DTLS_TRANSPORT_FAILED:
-      return webrtc::DtlsTransportState::kFailed;
-  }
-  RTC_NOTREACHED();
-  return webrtc::DtlsTransportState::kNew;
-}
-
 }  // namespace cricket
diff --git a/p2p/base/dtls_transport_internal.h b/p2p/base/dtls_transport_internal.h
index d0af5e8..0b26a7f 100644
--- a/p2p/base/dtls_transport_internal.h
+++ b/p2p/base/dtls_transport_internal.h
@@ -32,24 +32,6 @@
 
 namespace cricket {
 
-enum DtlsTransportState {
-  // Haven't started negotiating.
-  DTLS_TRANSPORT_NEW = static_cast<int>(webrtc::DtlsTransportState::kNew),
-  // Have started negotiating.
-  DTLS_TRANSPORT_CONNECTING =
-      static_cast<int>(webrtc::DtlsTransportState::kConnecting),
-  // Negotiated, and has a secure connection.
-  DTLS_TRANSPORT_CONNECTED =
-      static_cast<int>(webrtc::DtlsTransportState::kConnected),
-  // Transport is closed.
-  DTLS_TRANSPORT_CLOSED = static_cast<int>(webrtc::DtlsTransportState::kClosed),
-  // Failed due to some error in the handshake process.
-  DTLS_TRANSPORT_FAILED = static_cast<int>(webrtc::DtlsTransportState::kFailed),
-};
-
-webrtc::DtlsTransportState ConvertDtlsTransportState(
-    cricket::DtlsTransportState cricket_state);
-
 enum PacketFlags {
   PF_NORMAL = 0x00,       // A normal packet.
   PF_SRTP_BYPASS = 0x01,  // An encrypted SRTP packet; bypass any additional
@@ -66,7 +48,7 @@
  public:
   ~DtlsTransportInternal() override;
 
-  virtual DtlsTransportState dtls_state() const = 0;
+  virtual webrtc::DtlsTransportState dtls_state() const = 0;
 
   virtual int component() const = 0;
 
@@ -117,21 +99,6 @@
   // Expose the underneath IceTransport.
   virtual IceTransportInternal* ice_transport() = 0;
 
-  // F: void(DtlsTransportInternal*, const DtlsTransportState)
-  template <typename F>
-  void SubscribeDtlsState(F&& callback) {
-    dtls_state_callback_list_.AddReceiver(std::forward<F>(callback));
-  }
-
-  template <typename F>
-  void SubscribeDtlsState(const void* id, F&& callback) {
-    dtls_state_callback_list_.AddReceiver(id, std::forward<F>(callback));
-  }
-  // Unsubscribe the subscription with given id.
-  void UnsubscribeDtlsState(const void* id) {
-    dtls_state_callback_list_.RemoveReceivers(id);
-  }
-
   // F: void(DtlsTransportInternal*, const webrtc::DtlsTransportState)
   template <typename F>
   void SubscribeDtlsTransportState(F&& callback) {
@@ -149,10 +116,8 @@
   }
 
   void SendDtlsState(DtlsTransportInternal* transport,
-                     DtlsTransportState state) {
-    dtls_state_callback_list_.Send(transport, state);
-    dtls_transport_state_callback_list_.Send(transport,
-                                             ConvertDtlsTransportState(state));
+                     webrtc::DtlsTransportState state) {
+    dtls_transport_state_callback_list_.Send(transport, state);
   }
 
   // Emitted whenever the Dtls handshake failed on some transport channel.
@@ -173,10 +138,6 @@
   RTC_DISALLOW_COPY_AND_ASSIGN(DtlsTransportInternal);
   webrtc::CallbackList<const rtc::SSLHandshakeError>
       dtls_handshake_error_callback_list_;
-  // TODO(bugs.webrtc.org/12762): Remove in favor of
-  // dtls_transport_state_callback_list_.
-  webrtc::CallbackList<DtlsTransportInternal*, const DtlsTransportState>
-      dtls_state_callback_list_;
   webrtc::CallbackList<DtlsTransportInternal*, const webrtc::DtlsTransportState>
       dtls_transport_state_callback_list_;
 };
diff --git a/p2p/base/dtls_transport_unittest.cc b/p2p/base/dtls_transport_unittest.cc
index a2ad213..f01566d 100644
--- a/p2p/base/dtls_transport_unittest.cc
+++ b/p2p/base/dtls_transport_unittest.cc
@@ -15,6 +15,7 @@
 #include <set>
 #include <utility>
 
+#include "api/dtls_transport_interface.h"
 #include "p2p/base/fake_ice_transport.h"
 #include "p2p/base/packet_transport_internal.h"
 #include "rtc_base/checks.h"
@@ -668,18 +669,19 @@
           // Sanity check that the handshake hasn't already finished.
           EXPECT_FALSE(client1_.dtls_transport()->IsDtlsConnected() ||
                        client1_.dtls_transport()->dtls_state() ==
-                           DTLS_TRANSPORT_FAILED);
+                           webrtc::DtlsTransportState::kFailed);
           EXPECT_TRUE_SIMULATED_WAIT(
               client1_.dtls_transport()->IsDtlsConnected() ||
                   client1_.dtls_transport()->dtls_state() ==
-                      DTLS_TRANSPORT_FAILED,
+                      webrtc::DtlsTransportState::kFailed,
               kTimeout, fake_clock_);
           break;
       }
     }
 
-    DtlsTransportState expected_final_state =
-        valid_fingerprint ? DTLS_TRANSPORT_CONNECTED : DTLS_TRANSPORT_FAILED;
+    webrtc::DtlsTransportState expected_final_state =
+        valid_fingerprint ? webrtc::DtlsTransportState::kConnected
+                          : webrtc::DtlsTransportState::kFailed;
     EXPECT_EQ_SIMULATED_WAIT(expected_final_state,
                              client1_.dtls_transport()->dtls_state(), kTimeout,
                              fake_clock_);
diff --git a/p2p/base/fake_dtls_transport.h b/p2p/base/fake_dtls_transport.h
index 0628c4c..e02755c 100644
--- a/p2p/base/fake_dtls_transport.h
+++ b/p2p/base/fake_dtls_transport.h
@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "api/crypto/crypto_options.h"
+#include "api/dtls_transport_interface.h"
 #include "p2p/base/dtls_transport_internal.h"
 #include "p2p/base/fake_ice_transport.h"
 #include "rtc_base/fake_ssl_identity.h"
@@ -89,7 +90,7 @@
     ice_transport_->SetReceiving(receiving);
     set_receiving(receiving);
   }
-  void SetDtlsState(DtlsTransportState state) {
+  void SetDtlsState(webrtc::DtlsTransportState state) {
     dtls_state_ = state;
     SendDtlsState(this, dtls_state_);
   }
@@ -121,7 +122,7 @@
       if (!dtls_role_) {
         dtls_role_ = std::move(rtc::SSL_CLIENT);
       }
-      SetDtlsState(DTLS_TRANSPORT_CONNECTED);
+      SetDtlsState(webrtc::DtlsTransportState::kConnected);
       ice_transport_->SetDestination(
           static_cast<FakeIceTransport*>(dest->ice_transport()), asymmetric);
     } else {
@@ -133,7 +134,7 @@
   }
 
   // Fake DtlsTransportInternal implementation.
-  DtlsTransportState dtls_state() const override { return dtls_state_; }
+  webrtc::DtlsTransportState dtls_state() const override { return dtls_state_; }
   const std::string& transport_name() const override { return transport_name_; }
   int component() const override { return component_; }
   const rtc::SSLFingerprint& dtls_fingerprint() const {
@@ -295,7 +296,7 @@
   int crypto_suite_ = rtc::SRTP_AES128_CM_SHA1_80;
   absl::optional<int> ssl_cipher_suite_;
 
-  DtlsTransportState dtls_state_ = DTLS_TRANSPORT_NEW;
+  webrtc::DtlsTransportState dtls_state_ = webrtc::DtlsTransportState::kNew;
 
   bool receiving_ = false;
   bool writable_ = false;
diff --git a/pc/dtls_srtp_transport.cc b/pc/dtls_srtp_transport.cc
index f272ab79..ac091c6 100644
--- a/pc/dtls_srtp_transport.cc
+++ b/pc/dtls_srtp_transport.cc
@@ -15,6 +15,7 @@
 #include <string>
 #include <utility>
 
+#include "api/dtls_transport_interface.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/ssl_stream_adapter.h"
@@ -114,10 +115,9 @@
   auto rtcp_dtls_transport =
       rtcp_mux_enabled() ? nullptr : rtcp_dtls_transport_;
   return (rtp_dtls_transport_ &&
-          rtp_dtls_transport_->dtls_state() ==
-              cricket::DTLS_TRANSPORT_CONNECTED &&
+          rtp_dtls_transport_->dtls_state() == DtlsTransportState::kConnected &&
           (!rtcp_dtls_transport || rtcp_dtls_transport->dtls_state() ==
-                                       cricket::DTLS_TRANSPORT_CONNECTED));
+                                       DtlsTransportState::kConnected));
 }
 
 bool DtlsSrtpTransport::IsDtlsWritable() {
@@ -275,17 +275,16 @@
   }
 
   if (*old_dtls_transport) {
-    (*old_dtls_transport)->UnsubscribeDtlsState(this);
+    (*old_dtls_transport)->UnsubscribeDtlsTransportState(this);
   }
 
   *old_dtls_transport = new_dtls_transport;
 
   if (new_dtls_transport) {
-    new_dtls_transport->SubscribeDtlsState(
-        this, [this](cricket::DtlsTransportInternal* transport,
-                     cricket::DtlsTransportState state) {
-          OnDtlsState(transport, state);
-        });
+    new_dtls_transport->SubscribeDtlsTransportState(
+        this,
+        [this](cricket::DtlsTransportInternal* transport,
+               DtlsTransportState state) { OnDtlsState(transport, state); });
   }
 }
 
@@ -300,7 +299,7 @@
 }
 
 void DtlsSrtpTransport::OnDtlsState(cricket::DtlsTransportInternal* transport,
-                                    cricket::DtlsTransportState state) {
+                                    DtlsTransportState state) {
   RTC_DCHECK(transport == rtp_dtls_transport_ ||
              transport == rtcp_dtls_transport_);
 
@@ -308,7 +307,7 @@
     on_dtls_state_change_();
   }
 
-  if (state != cricket::DTLS_TRANSPORT_CONNECTED) {
+  if (state != DtlsTransportState::kConnected) {
     ResetParams();
     return;
   }
diff --git a/pc/dtls_srtp_transport.h b/pc/dtls_srtp_transport.h
index bc82fd5..9c52dcf 100644
--- a/pc/dtls_srtp_transport.h
+++ b/pc/dtls_srtp_transport.h
@@ -16,6 +16,7 @@
 
 #include "absl/types/optional.h"
 #include "api/crypto_params.h"
+#include "api/dtls_transport_interface.h"
 #include "api/rtc_error.h"
 #include "p2p/base/dtls_transport_internal.h"
 #include "p2p/base/packet_transport_internal.h"
@@ -82,7 +83,7 @@
       cricket::DtlsTransportInternal* rtcp_dtls_transport);
 
   void OnDtlsState(cricket::DtlsTransportInternal* dtls_transport,
-                   cricket::DtlsTransportState state);
+                   DtlsTransportState state);
 
   // Override the SrtpTransport::OnWritableState.
   void OnWritableState(rtc::PacketTransportInternal* packet_transport) override;
diff --git a/pc/dtls_transport.cc b/pc/dtls_transport.cc
index 1369db1..074f44e 100644
--- a/pc/dtls_transport.cc
+++ b/pc/dtls_transport.cc
@@ -13,6 +13,7 @@
 #include <utility>
 
 #include "absl/types/optional.h"
+#include "api/dtls_transport_interface.h"
 #include "api/sequence_checker.h"
 #include "pc/ice_transport.h"
 #include "rtc_base/checks.h"
@@ -22,26 +23,6 @@
 
 namespace webrtc {
 
-namespace {
-
-DtlsTransportState TranslateState(cricket::DtlsTransportState internal_state) {
-  switch (internal_state) {
-    case cricket::DTLS_TRANSPORT_NEW:
-      return DtlsTransportState::kNew;
-    case cricket::DTLS_TRANSPORT_CONNECTING:
-      return DtlsTransportState::kConnecting;
-    case cricket::DTLS_TRANSPORT_CONNECTED:
-      return DtlsTransportState::kConnected;
-    case cricket::DTLS_TRANSPORT_CLOSED:
-      return DtlsTransportState::kClosed;
-    case cricket::DTLS_TRANSPORT_FAILED:
-      return DtlsTransportState::kFailed;
-  }
-  RTC_CHECK_NOTREACHED();
-}
-
-}  // namespace
-
 // Implementation of DtlsTransportInterface
 DtlsTransport::DtlsTransport(
     std::unique_ptr<cricket::DtlsTransportInternal> internal)
@@ -51,9 +32,9 @@
       ice_transport_(rtc::make_ref_counted<IceTransportWithPointer>(
           internal_dtls_transport_->ice_transport())) {
   RTC_DCHECK(internal_dtls_transport_.get());
-  internal_dtls_transport_->SubscribeDtlsState(
+  internal_dtls_transport_->SubscribeDtlsTransportState(
       [this](cricket::DtlsTransportInternal* transport,
-             cricket::DtlsTransportState state) {
+             DtlsTransportState state) {
         OnInternalDtlsState(transport, state);
       });
   UpdateInformation();
@@ -90,7 +71,7 @@
   RTC_DCHECK_RUN_ON(owner_thread_);
   RTC_DCHECK(internal());
   bool must_send_event =
-      (internal()->dtls_state() != cricket::DTLS_TRANSPORT_CLOSED);
+      (internal()->dtls_state() != DtlsTransportState::kClosed);
   // The destructor of cricket::DtlsTransportInternal calls back
   // into DtlsTransport, so we can't hold the lock while releasing.
   std::unique_ptr<cricket::DtlsTransportInternal> transport_to_release;
@@ -107,7 +88,7 @@
 
 void DtlsTransport::OnInternalDtlsState(
     cricket::DtlsTransportInternal* transport,
-    cricket::DtlsTransportState state) {
+    DtlsTransportState state) {
   RTC_DCHECK_RUN_ON(owner_thread_);
   RTC_DCHECK(transport == internal());
   RTC_DCHECK(state == internal()->dtls_state());
@@ -122,7 +103,7 @@
   MutexLock lock(&lock_);
   if (internal_dtls_transport_) {
     if (internal_dtls_transport_->dtls_state() ==
-        cricket::DTLS_TRANSPORT_CONNECTED) {
+        DtlsTransportState::kConnected) {
       bool success = true;
       int ssl_cipher_suite;
       int tls_version;
@@ -132,20 +113,19 @@
       success &= internal_dtls_transport_->GetSrtpCryptoSuite(&srtp_cipher);
       if (success) {
         info_ = DtlsTransportInformation(
-            TranslateState(internal_dtls_transport_->dtls_state()), tls_version,
+            internal_dtls_transport_->dtls_state(), tls_version,
             ssl_cipher_suite, srtp_cipher,
             internal_dtls_transport_->GetRemoteSSLCertChain());
       } else {
         RTC_LOG(LS_ERROR) << "DtlsTransport in connected state has incomplete "
                              "TLS information";
         info_ = DtlsTransportInformation(
-            TranslateState(internal_dtls_transport_->dtls_state()),
-            absl::nullopt, absl::nullopt, absl::nullopt,
+            internal_dtls_transport_->dtls_state(), absl::nullopt,
+            absl::nullopt, absl::nullopt,
             internal_dtls_transport_->GetRemoteSSLCertChain());
       }
     } else {
-      info_ = DtlsTransportInformation(
-          TranslateState(internal_dtls_transport_->dtls_state()));
+      info_ = DtlsTransportInformation(internal_dtls_transport_->dtls_state());
     }
   } else {
     info_ = DtlsTransportInformation(DtlsTransportState::kClosed);
diff --git a/pc/dtls_transport.h b/pc/dtls_transport.h
index 893b126..cca4cc9 100644
--- a/pc/dtls_transport.h
+++ b/pc/dtls_transport.h
@@ -60,7 +60,7 @@
 
  private:
   void OnInternalDtlsState(cricket::DtlsTransportInternal* transport,
-                           cricket::DtlsTransportState state);
+                           DtlsTransportState state);
   void UpdateInformation();
 
   DtlsTransportObserverInterface* observer_ = nullptr;
diff --git a/pc/jsep_transport_controller.cc b/pc/jsep_transport_controller.cc
index 372f4f6..05f8b3a 100644
--- a/pc/jsep_transport_controller.cc
+++ b/pc/jsep_transport_controller.cc
@@ -17,6 +17,7 @@
 #include <utility>
 
 #include "absl/algorithm/container.h"
+#include "api/dtls_transport_interface.h"
 #include "api/rtp_parameters.h"
 #include "api/sequence_checker.h"
 #include "api/transport/enums.h"
@@ -1291,7 +1292,7 @@
   bool all_done_gathering = !dtls_transports.empty();
 
   std::map<IceTransportState, int> ice_state_counts;
-  std::map<cricket::DtlsTransportState, int> dtls_state_counts;
+  std::map<DtlsTransportState, int> dtls_state_counts;
 
   for (const auto& dtls : dtls_transports) {
     any_failed = any_failed || dtls->ice_transport()->GetState() ==
@@ -1393,16 +1394,15 @@
   // Note that "connecting" is only a valid state for DTLS transports while
   // "checking", "completed" and "disconnected" are only valid for ICE
   // transports.
-  int total_connected = total_ice_connected +
-                        dtls_state_counts[cricket::DTLS_TRANSPORT_CONNECTED];
+  int total_connected =
+      total_ice_connected + dtls_state_counts[DtlsTransportState::kConnected];
   int total_dtls_connecting =
-      dtls_state_counts[cricket::DTLS_TRANSPORT_CONNECTING];
+      dtls_state_counts[DtlsTransportState::kConnecting];
   int total_failed =
-      total_ice_failed + dtls_state_counts[cricket::DTLS_TRANSPORT_FAILED];
+      total_ice_failed + dtls_state_counts[DtlsTransportState::kFailed];
   int total_closed =
-      total_ice_closed + dtls_state_counts[cricket::DTLS_TRANSPORT_CLOSED];
-  int total_new =
-      total_ice_new + dtls_state_counts[cricket::DTLS_TRANSPORT_NEW];
+      total_ice_closed + dtls_state_counts[DtlsTransportState::kClosed];
+  int total_new = total_ice_new + dtls_state_counts[DtlsTransportState::kNew];
   int total_transports = total_ice * 2;
 
   if (total_failed > 0) {
diff --git a/pc/jsep_transport_controller_unittest.cc b/pc/jsep_transport_controller_unittest.cc
index d13a94c..2b261c8 100644
--- a/pc/jsep_transport_controller_unittest.cc
+++ b/pc/jsep_transport_controller_unittest.cc
@@ -13,6 +13,7 @@
 #include <map>
 #include <memory>
 
+#include "api/dtls_transport_interface.h"
 #include "p2p/base/dtls_transport_factory.h"
 #include "p2p/base/fake_dtls_transport.h"
 #include "p2p/base/fake_ice_transport.h"
@@ -693,8 +694,8 @@
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(2, combined_connection_state_signal_count_);
 
-  fake_audio_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
-  fake_video_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
+  fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
+  fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
   // Set the connection count to be 2 and the cricket::FakeIceTransport will set
   // the transport state to be STATE_CONNECTING.
   fake_video_dtls->fake_ice_transport()->SetConnectionCount(2);
@@ -750,8 +751,8 @@
                  combined_connection_state_, kTimeout);
   EXPECT_EQ(2, combined_connection_state_signal_count_);
 
-  fake_audio_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
-  fake_video_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
+  fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
+  fake_video_dtls->SetDtlsState(DtlsTransportState::kConnected);
   // Set the connection count to be 1 and the cricket::FakeIceTransport will set
   // the transport state to be STATE_COMPLETED.
   fake_video_dtls->fake_ice_transport()->SetTransportState(
@@ -839,7 +840,7 @@
   fake_audio_dtls->SetWritable(true);
   fake_audio_dtls->fake_ice_transport()->SetCandidatesGatheringComplete();
   fake_audio_dtls->fake_ice_transport()->SetConnectionCount(1);
-  fake_audio_dtls->SetDtlsState(cricket::DTLS_TRANSPORT_CONNECTED);
+  fake_audio_dtls->SetDtlsState(DtlsTransportState::kConnected);
   EXPECT_EQ(1, gathering_state_signal_count_);
 
   // Set the remote description and enable the bundle.
diff --git a/pc/rtc_stats_collector.cc b/pc/rtc_stats_collector.cc
index 7e781a7..f3a94b0 100644
--- a/pc/rtc_stats_collector.cc
+++ b/pc/rtc_stats_collector.cc
@@ -209,20 +209,20 @@
 }
 
 const char* DtlsTransportStateToRTCDtlsTransportState(
-    cricket::DtlsTransportState state) {
+    DtlsTransportState state) {
   switch (state) {
-    case cricket::DTLS_TRANSPORT_NEW:
+    case DtlsTransportState::kNew:
       return RTCDtlsTransportState::kNew;
-    case cricket::DTLS_TRANSPORT_CONNECTING:
+    case DtlsTransportState::kConnecting:
       return RTCDtlsTransportState::kConnecting;
-    case cricket::DTLS_TRANSPORT_CONNECTED:
+    case DtlsTransportState::kConnected:
       return RTCDtlsTransportState::kConnected;
-    case cricket::DTLS_TRANSPORT_CLOSED:
+    case DtlsTransportState::kClosed:
       return RTCDtlsTransportState::kClosed;
-    case cricket::DTLS_TRANSPORT_FAILED:
+    case DtlsTransportState::kFailed:
       return RTCDtlsTransportState::kFailed;
     default:
-      RTC_NOTREACHED();
+      RTC_CHECK_NOTREACHED();
       return nullptr;
   }
 }
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index 6a56839..def98d4 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -22,6 +22,7 @@
 
 #include "absl/memory/memory.h"
 #include "absl/strings/str_replace.h"
+#include "api/dtls_transport_interface.h"
 #include "api/media_stream_track.h"
 #include "api/rtp_parameters.h"
 #include "api/stats/rtc_stats_report.h"
@@ -2322,7 +2323,7 @@
   rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
   rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
       rtp_connection_info);
-  rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
+  rtp_transport_channel_stats.dtls_state = DtlsTransportState::kNew;
   rtp_transport_channel_stats.ice_transport_stats
       .selected_candidate_pair_changes = 1;
   pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
@@ -2360,7 +2361,7 @@
       cricket::ICE_CANDIDATE_COMPONENT_RTCP;
   rtcp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
       rtcp_connection_info);
-  rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTING;
+  rtcp_transport_channel_stats.dtls_state = DtlsTransportState::kConnecting;
   pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats,
                                           rtcp_transport_channel_stats});
 
@@ -2476,7 +2477,7 @@
   rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
       rtp_connection_info);
   // The state must be connected in order for crypto parameters to show up.
-  rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTED;
+  rtp_transport_channel_stats.dtls_state = DtlsTransportState::kConnected;
   rtp_transport_channel_stats.ice_transport_stats
       .selected_candidate_pair_changes = 1;
   rtp_transport_channel_stats.ssl_version_bytes = 0x0203;
@@ -2963,11 +2964,11 @@
 
   cricket::TransportChannelStats rtp_transport_channel_stats;
   rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
-  rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
+  rtp_transport_channel_stats.dtls_state = DtlsTransportState::kNew;
   cricket::TransportChannelStats rtcp_transport_channel_stats;
   rtcp_transport_channel_stats.component =
       cricket::ICE_CANDIDATE_COMPONENT_RTCP;
-  rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
+  rtcp_transport_channel_stats.dtls_state = DtlsTransportState::kNew;
   pc_->SetTransportStats("TransportName", {rtp_transport_channel_stats,
                                            rtcp_transport_channel_stats});
   AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
diff --git a/pc/sctp_transport.cc b/pc/sctp_transport.cc
index 14a09d7..7d4e455 100644
--- a/pc/sctp_transport.cc
+++ b/pc/sctp_transport.cc
@@ -14,6 +14,7 @@
 #include <utility>
 
 #include "absl/types/optional.h"
+#include "api/dtls_transport_interface.h"
 #include "api/sequence_checker.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/location.h"
@@ -95,9 +96,9 @@
     if (transport) {
       internal_sctp_transport_->SetDtlsTransport(transport->internal());
 
-      transport->internal()->SubscribeDtlsState(
+      transport->internal()->SubscribeDtlsTransportState(
           [this](cricket::DtlsTransportInternal* transport,
-                 cricket::DtlsTransportState state) {
+                 DtlsTransportState state) {
             OnDtlsStateChange(transport, state);
           });
       if (info_.state() == SctpTransportState::kNew) {
@@ -159,11 +160,11 @@
 }
 
 void SctpTransport::OnDtlsStateChange(cricket::DtlsTransportInternal* transport,
-                                      cricket::DtlsTransportState state) {
+                                      DtlsTransportState state) {
   RTC_DCHECK_RUN_ON(owner_thread_);
   RTC_CHECK(transport == dtls_transport_->internal());
-  if (state == cricket::DTLS_TRANSPORT_CLOSED ||
-      state == cricket::DTLS_TRANSPORT_FAILED) {
+  if (state == DtlsTransportState::kClosed ||
+      state == DtlsTransportState::kFailed) {
     UpdateInformation(SctpTransportState::kClosed);
     // TODO(http://bugs.webrtc.org/11090): Close all the data channels
   }
diff --git a/pc/sctp_transport.h b/pc/sctp_transport.h
index a8bc45b..87fde53 100644
--- a/pc/sctp_transport.h
+++ b/pc/sctp_transport.h
@@ -71,7 +71,7 @@
   void OnInternalClosingProcedureStartedRemotely(int sid);
   void OnInternalClosingProcedureComplete(int sid);
   void OnDtlsStateChange(cricket::DtlsTransportInternal* transport,
-                         cricket::DtlsTransportState state);
+                         DtlsTransportState state);
 
   // NOTE: |owner_thread_| is the thread that the SctpTransport object is
   // constructed on. In the context of PeerConnection, it's the network thread.
diff --git a/pc/sctp_transport_unittest.cc b/pc/sctp_transport_unittest.cc
index b4618ed..679b481 100644
--- a/pc/sctp_transport_unittest.cc
+++ b/pc/sctp_transport_unittest.cc
@@ -14,6 +14,7 @@
 #include <vector>
 
 #include "absl/memory/memory.h"
+#include "api/dtls_transport_interface.h"
 #include "p2p/base/fake_dtls_transport.h"
 #include "pc/dtls_transport.h"
 #include "rtc_base/gunit.h"
@@ -204,7 +205,7 @@
   ASSERT_EQ_WAIT(SctpTransportState::kConnected, observer_.State(),
                  kDefaultTimeout);
   static_cast<cricket::FakeDtlsTransport*>(dtls_transport_->internal())
-      ->SetDtlsState(cricket::DTLS_TRANSPORT_CLOSED);
+      ->SetDtlsState(DtlsTransportState::kClosed);
   ASSERT_EQ_WAIT(SctpTransportState::kClosed, observer_.State(),
                  kDefaultTimeout);
 }
diff --git a/pc/transport_stats.h b/pc/transport_stats.h
index 7cb95f4..173af91 100644
--- a/pc/transport_stats.h
+++ b/pc/transport_stats.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 
+#include "api/dtls_transport_interface.h"
 #include "p2p/base/dtls_transport_internal.h"
 #include "p2p/base/ice_transport_internal.h"
 #include "p2p/base/port.h"
@@ -30,7 +31,7 @@
   int ssl_version_bytes = 0;
   int srtp_crypto_suite = rtc::SRTP_INVALID_CRYPTO_SUITE;
   int ssl_cipher_suite = rtc::TLS_NULL_WITH_NULL_NULL;
-  DtlsTransportState dtls_state = DTLS_TRANSPORT_NEW;
+  webrtc::DtlsTransportState dtls_state = webrtc::DtlsTransportState::kNew;
   IceTransportStats ice_transport_stats;
 };