Bug 1550177 - Part 1: Remove some duplicate webidl enums. r=mjf,smaug

Differential Revision: https://phabricator.services.mozilla.com/D30991

--HG--
extra : moz-landing-system : lando

dom/media/PeerConnection.jsm

@@ -1580,15 +1580,7 @@ class RTCPeerConnection {
     if (this._closed) {
       return "closed";
     }
-    return {
-      "SignalingInvalid":            "",
-      "SignalingStable":             "stable",
-      "SignalingHaveLocalOffer":     "have-local-offer",
-      "SignalingHaveRemoteOffer":    "have-remote-offer",
-      "SignalingHaveLocalPranswer":  "have-local-pranswer",
-      "SignalingHaveRemotePranswer": "have-remote-pranswer",
-      "SignalingClosed":             "closed",
-    }[this._impl.signalingState];
+    return this._impl.signalingState;
   }
 
   changeIceGatheringState(state) {

dom/webidl/PeerConnectionImpl.webidl

@@ -116,9 +116,9 @@ interface PeerConnectionImpl  {
   readonly attribute DOMString currentRemoteDescription;
   readonly attribute DOMString pendingRemoteDescription;
 
-  readonly attribute PCImplIceConnectionState iceConnectionState;
-  readonly attribute PCImplIceGatheringState iceGatheringState;
-  readonly attribute PCImplSignalingState signalingState;
+  readonly attribute RTCIceConnectionState iceConnectionState;
+  readonly attribute RTCIceGatheringState iceGatheringState;
+  readonly attribute RTCSignalingState signalingState;
   attribute DOMString id;
 
   [SetterThrows]

dom/webidl/PeerConnectionImplEnums.webidl

@@ -1,36 +0,0 @@
-/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this file,
- * You can obtain one at http://mozilla.org/MPL/2.0/.
- *
- * This is in a separate file so it can be shared with unittests.
- */
-
-/* Must be in the same order as comparable fsmdef_states_t in fsmdef_states.h */
-enum PCImplSignalingState {
-  "SignalingInvalid",
-  "SignalingStable",
-  "SignalingHaveLocalOffer",
-  "SignalingHaveRemoteOffer",
-  "SignalingHaveLocalPranswer",
-  "SignalingHaveRemotePranswer",
-  "SignalingClosed",
-};
-
-enum PCImplIceConnectionState {
-    "new",
-    "checking",
-    "connected",
-    "completed",
-    "failed",
-    "disconnected",
-    "closed"
-};
-
-// Deliberately identical to the values specified in webrtc
-enum PCImplIceGatheringState {
-  "new",
-  "gathering",
-  "complete"
-};
-

dom/webidl/moz.build

@@ -965,7 +965,6 @@ WEBIDL_FILES = [
 if CONFIG['MOZ_WEBRTC']:
     WEBIDL_FILES += [
         'PeerConnectionImpl.webidl',
-        'PeerConnectionImplEnums.webidl',
         'PeerConnectionObserver.webidl',
         'PeerConnectionObserverEnums.webidl',
         'RTCCertificate.webidl',

media/webrtc/signaling/src/peerconnection/MediaTransportHandler.cpp

@@ -640,7 +640,7 @@ void MediaTransportHandlerSTS::StartIceGathering(
   // If there are no streams, we're probably in a situation where we've rolled
   // back while still waiting for our proxy configuration to come back. Make
   // sure content knows that the rollback has stuck wrt gathering.
-  OnGatheringStateChange(dom::PCImplIceGatheringState::Complete);
+  OnGatheringStateChange(dom::RTCIceGatheringState::Complete);
 }
 
 void MediaTransportHandlerSTS::StartIceChecks(
@@ -885,7 +885,7 @@ void MediaTransportHandler::OnAlpnNegotiated(const std::string& aAlpn) {
 }
 
 void MediaTransportHandler::OnGatheringStateChange(
-    dom::PCImplIceGatheringState aState) {
+    dom::RTCIceGatheringState aState) {
   if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) {
     mCallbackThread->Dispatch(
         WrapRunnable(RefPtr<MediaTransportHandler>(this),
@@ -898,7 +898,7 @@ void MediaTransportHandler::OnGatheringStateChange(
 }
 
 void MediaTransportHandler::OnConnectionStateChange(
-    dom::PCImplIceConnectionState aState) {
+    dom::RTCIceConnectionState aState) {
   if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) {
     mCallbackThread->Dispatch(
         WrapRunnable(RefPtr<MediaTransportHandler>(this),
@@ -1261,15 +1261,15 @@ RefPtr<TransportFlow> MediaTransportHandlerSTS::CreateTransportFlow(
   return flow;
 }
 
-static mozilla::dom::PCImplIceGatheringState toDomIceGatheringState(
+static mozilla::dom::RTCIceGatheringState toDomIceGatheringState(
     NrIceCtx::GatheringState aState) {
   switch (aState) {
     case NrIceCtx::ICE_CTX_GATHER_INIT:
-      return dom::PCImplIceGatheringState::New;
+      return dom::RTCIceGatheringState::New;
     case NrIceCtx::ICE_CTX_GATHER_STARTED:
-      return dom::PCImplIceGatheringState::Gathering;
+      return dom::RTCIceGatheringState::Gathering;
     case NrIceCtx::ICE_CTX_GATHER_COMPLETE:
-      return dom::PCImplIceGatheringState::Complete;
+      return dom::RTCIceGatheringState::Complete;
   }
   MOZ_CRASH();
 }
@@ -1279,23 +1279,23 @@ void MediaTransportHandlerSTS::OnGatheringStateChange(
   OnGatheringStateChange(toDomIceGatheringState(aState));
 }
 
-static mozilla::dom::PCImplIceConnectionState toDomIceConnectionState(
+static mozilla::dom::RTCIceConnectionState toDomIceConnectionState(
     NrIceCtx::ConnectionState aState) {
   switch (aState) {
     case NrIceCtx::ICE_CTX_INIT:
-      return dom::PCImplIceConnectionState::New;
+      return dom::RTCIceConnectionState::New;
     case NrIceCtx::ICE_CTX_CHECKING:
-      return dom::PCImplIceConnectionState::Checking;
+      return dom::RTCIceConnectionState::Checking;
     case NrIceCtx::ICE_CTX_CONNECTED:
-      return dom::PCImplIceConnectionState::Connected;
+      return dom::RTCIceConnectionState::Connected;
     case NrIceCtx::ICE_CTX_COMPLETED:
-      return dom::PCImplIceConnectionState::Completed;
+      return dom::RTCIceConnectionState::Completed;
     case NrIceCtx::ICE_CTX_FAILED:
-      return dom::PCImplIceConnectionState::Failed;
+      return dom::RTCIceConnectionState::Failed;
     case NrIceCtx::ICE_CTX_DISCONNECTED:
-      return dom::PCImplIceConnectionState::Disconnected;
+      return dom::RTCIceConnectionState::Disconnected;
     case NrIceCtx::ICE_CTX_CLOSED:
-      return dom::PCImplIceConnectionState::Closed;
+      return dom::RTCIceConnectionState::Closed;
   }
   MOZ_CRASH();
 }

media/webrtc/signaling/src/peerconnection/MediaTransportHandler.h

@@ -10,7 +10,7 @@
 #include "sigslot.h"
 #include "transportlayer.h"  // Need the State enum
 #include "dtlsidentity.h"    // For DtlsDigest
-#include "mozilla/dom/PeerConnectionImplEnumsBinding.h"
+#include "mozilla/dom/RTCPeerConnectionBinding.h"
 #include "mozilla/dom/RTCConfigurationBinding.h"
 #include "nricectx.h"               // Need some enums
 #include "nsDOMNavigationTiming.h"  // DOMHighResTimeStamp
@@ -120,8 +120,8 @@ class MediaTransportHandler {
 
   sigslot::signal2<const std::string&, const CandidateInfo&> SignalCandidate;
   sigslot::signal1<const std::string&> SignalAlpnNegotiated;
-  sigslot::signal1<dom::PCImplIceGatheringState> SignalGatheringStateChange;
-  sigslot::signal1<dom::PCImplIceConnectionState> SignalConnectionStateChange;
+  sigslot::signal1<dom::RTCIceGatheringState> SignalGatheringStateChange;
+  sigslot::signal1<dom::RTCIceConnectionState> SignalConnectionStateChange;
 
   sigslot::signal2<const std::string&, MediaPacket&> SignalPacketReceived;
   sigslot::signal2<const std::string&, MediaPacket&> SignalEncryptedSending;
@@ -137,8 +137,8 @@ class MediaTransportHandler {
   void OnCandidate(const std::string& aTransportId,
                    const CandidateInfo& aCandidateInfo);
   void OnAlpnNegotiated(const std::string& aAlpn);
-  void OnGatheringStateChange(dom::PCImplIceGatheringState aState);
-  void OnConnectionStateChange(dom::PCImplIceConnectionState aState);
+  void OnGatheringStateChange(dom::RTCIceGatheringState aState);
+  void OnConnectionStateChange(dom::RTCIceConnectionState aState);
   void OnPacketReceived(const std::string& aTransportId, MediaPacket& aPacket);
   void OnEncryptedSending(const std::string& aTransportId,
                           MediaPacket& aPacket);

media/webrtc/signaling/src/peerconnection/MediaTransportHandlerIPC.cpp

@@ -333,8 +333,7 @@ mozilla::ipc::IPCResult MediaTransportChild::RecvOnAlpnNegotiated(
 mozilla::ipc::IPCResult MediaTransportChild::RecvOnGatheringStateChange(
     const int& state) {
   MOZ_ASSERT(GetMainThreadEventTarget()->IsOnCurrentThread());
-  mUser->OnGatheringStateChange(
-      static_cast<dom::PCImplIceGatheringState>(state));
+  mUser->OnGatheringStateChange(static_cast<dom::RTCIceGatheringState>(state));
   return ipc::IPCResult::Ok();
 }
 
@@ -342,7 +341,7 @@ mozilla::ipc::IPCResult MediaTransportChild::RecvOnConnectionStateChange(
     const int& state) {
   MOZ_ASSERT(GetMainThreadEventTarget()->IsOnCurrentThread());
   mUser->OnConnectionStateChange(
-      static_cast<dom::PCImplIceConnectionState>(state));
+      static_cast<dom::RTCIceConnectionState>(state));
   return ipc::IPCResult::Ok();
 }
 

media/webrtc/signaling/src/peerconnection/MediaTransportParent.cpp

@@ -52,12 +52,12 @@ class MediaTransportParent::Impl : public sigslot::has_slots<> {
     NS_ENSURE_TRUE_VOID(mParent->SendOnAlpnNegotiated(aAlpn));
   }
 
-  void OnGatheringStateChange(dom::PCImplIceGatheringState aState) {
+  void OnGatheringStateChange(dom::RTCIceGatheringState aState) {
     NS_ENSURE_TRUE_VOID(
         mParent->SendOnGatheringStateChange(static_cast<int>(aState)));
   }
 
-  void OnConnectionStateChange(dom::PCImplIceConnectionState aState) {
+  void OnConnectionStateChange(dom::RTCIceConnectionState aState) {
     NS_ENSURE_TRUE_VOID(
         mParent->SendOnConnectionStateChange(static_cast<int>(aState)));
   }

media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp

@@ -294,9 +294,9 @@ bool IsPrivateBrowsing(nsPIDOMWindowInner* aWindow) {
 PeerConnectionImpl::PeerConnectionImpl(const GlobalObject* aGlobal)
     : mTimeCard(MOZ_LOG_TEST(logModuleInfo, LogLevel::Error) ? create_timecard()
                                                              : nullptr),
-      mSignalingState(PCImplSignalingState::SignalingStable),
-      mIceConnectionState(PCImplIceConnectionState::New),
-      mIceGatheringState(PCImplIceGatheringState::New),
+      mSignalingState(RTCSignalingState::Stable),
+      mIceConnectionState(RTCIceConnectionState::New),
+      mIceGatheringState(RTCIceGatheringState::New),
       mWindow(nullptr),
       mCertificate(nullptr),
       mSTSThread(nullptr),
@@ -1015,7 +1015,7 @@ already_AddRefed<TransceiverImpl> PeerConnectionImpl::CreateTransceiverImpl(
 }
 
 bool PeerConnectionImpl::CheckNegotiationNeeded(ErrorResult& rv) {
-  MOZ_ASSERT(mSignalingState == PCImplSignalingState::SignalingStable);
+  MOZ_ASSERT(mSignalingState == RTCSignalingState::Stable);
   return mJsepSession->CheckNegotiationNeeded();
 }
 
@@ -1521,7 +1521,7 @@ PeerConnectionImpl::AddIceCandidate(
   // we won't record them as trickle candidates. Is this what we want?
   if (!mIceStartTime.IsNull()) {
     TimeDuration timeDelta = TimeStamp::Now() - mIceStartTime;
-    if (mIceConnectionState == PCImplIceConnectionState::Failed) {
+    if (mIceConnectionState == RTCIceConnectionState::Failed) {
       Telemetry::Accumulate(Telemetry::WEBRTC_ICE_LATE_TRICKLE_ARRIVAL_TIME,
                             timeDelta.ToMilliseconds());
     } else {
@@ -1542,8 +1542,7 @@ PeerConnectionImpl::AddIceCandidate(
     // We do not bother PCMedia about this before offer/answer concludes.
     // Once offer/answer concludes, PCMedia will extract these candidates from
     // the remote SDP.
-    if (mSignalingState == PCImplSignalingState::SignalingStable &&
-        !transportId.empty()) {
+    if (mSignalingState == RTCSignalingState::Stable && !transportId.empty()) {
       mMedia->AddIceCandidate(aCandidate, transportId, aUfrag);
       mRawTrickledCandidates.push_back(aCandidate);
     }
@@ -2036,7 +2035,7 @@ void PeerConnectionImpl::GetPendingRemoteDescription(nsAString& aSDP) {
 }
 
 NS_IMETHODIMP
-PeerConnectionImpl::SignalingState(PCImplSignalingState* aState) {
+PeerConnectionImpl::SignalingState(RTCSignalingState* aState) {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
   MOZ_ASSERT(aState);
 
@@ -2045,7 +2044,7 @@ PeerConnectionImpl::SignalingState(PCImplSignalingState* aState) {
 }
 
 NS_IMETHODIMP
-PeerConnectionImpl::IceConnectionState(PCImplIceConnectionState* aState) {
+PeerConnectionImpl::IceConnectionState(RTCIceConnectionState* aState) {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
   MOZ_ASSERT(aState);
 
@@ -2054,7 +2053,7 @@ PeerConnectionImpl::IceConnectionState(PCImplIceConnectionState* aState) {
 }
 
 NS_IMETHODIMP
-PeerConnectionImpl::IceGatheringState(PCImplIceGatheringState* aState) {
+PeerConnectionImpl::IceGatheringState(RTCIceGatheringState* aState) {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
   MOZ_ASSERT(aState);
 
@@ -2065,7 +2064,7 @@ PeerConnectionImpl::IceGatheringState(PCImplIceGatheringState* aState) {
 nsresult PeerConnectionImpl::CheckApiState(bool assert_ice_ready) const {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
   MOZ_ASSERT(mTrickle || !assert_ice_ready ||
-             (mIceGatheringState == PCImplIceGatheringState::Complete));
+             (mIceGatheringState == RTCIceGatheringState::Complete));
 
   if (IsClosed()) {
     CSFLogError(LOGTAG, "%s: called API while closed", __FUNCTION__);
@@ -2083,7 +2082,7 @@ PeerConnectionImpl::Close() {
   CSFLogDebug(LOGTAG, "%s: for %s", __FUNCTION__, mHandle.c_str());
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
 
-  SetSignalingState_m(PCImplSignalingState::SignalingClosed);
+  SetSignalingState_m(RTCSignalingState::Closed);
 
   return NS_OK;
 }
@@ -2235,17 +2234,16 @@ void PeerConnectionImpl::ShutdownMedia() {
   mMedia.forget().take()->SelfDestruct();
 }
 
-void PeerConnectionImpl::SetSignalingState_m(
-    PCImplSignalingState aSignalingState, bool rollback) {
+void PeerConnectionImpl::SetSignalingState_m(RTCSignalingState aSignalingState,
+                                             bool rollback) {
   PC_AUTO_ENTER_API_CALL_NO_CHECK();
-  if (mSignalingState == PCImplSignalingState::SignalingClosed) {
+  if (mSignalingState == RTCSignalingState::Closed) {
     return;
   }
 
-  if (aSignalingState == PCImplSignalingState::SignalingHaveLocalOffer ||
-      (aSignalingState == PCImplSignalingState::SignalingStable &&
-       mSignalingState == PCImplSignalingState::SignalingHaveRemoteOffer &&
-       !rollback)) {
+  if (aSignalingState == RTCSignalingState::Have_local_offer ||
+      (aSignalingState == RTCSignalingState::Stable &&
+       mSignalingState == RTCSignalingState::Have_remote_offer && !rollback)) {
     mMedia->EnsureTransports(*mJsepSession);
   }
 
@@ -2255,7 +2253,7 @@ void PeerConnectionImpl::SetSignalingState_m(
 
   mSignalingState = aSignalingState;
 
-  if (mSignalingState == PCImplSignalingState::SignalingStable) {
+  if (mSignalingState == RTCSignalingState::Stable) {
     // If we're rolling back a local offer, we might need to remove some
     // transports, and stomp some MediaPipeline setup, but nothing further
     // needs to be done.
@@ -2290,7 +2288,7 @@ void PeerConnectionImpl::SetSignalingState_m(
     }
   }
 
-  if (mSignalingState == PCImplSignalingState::SignalingClosed) {
+  if (mSignalingState == RTCSignalingState::Closed) {
     CloseInt();
     // Uncount this connection as active on the inner window upon close.
     if (mWindow && mActiveOnWindow) {
@@ -2306,26 +2304,26 @@ void PeerConnectionImpl::SetSignalingState_m(
 void PeerConnectionImpl::UpdateSignalingState(bool rollback) {
   mozilla::JsepSignalingState state = mJsepSession->GetState();
 
-  PCImplSignalingState newState;
+  RTCSignalingState newState;
 
   switch (state) {
     case kJsepStateStable:
-      newState = PCImplSignalingState::SignalingStable;
+      newState = RTCSignalingState::Stable;
       break;
     case kJsepStateHaveLocalOffer:
-      newState = PCImplSignalingState::SignalingHaveLocalOffer;
+      newState = RTCSignalingState::Have_local_offer;
       break;
     case kJsepStateHaveRemoteOffer:
-      newState = PCImplSignalingState::SignalingHaveRemoteOffer;
+      newState = RTCSignalingState::Have_remote_offer;
       break;
     case kJsepStateHaveLocalPranswer:
-      newState = PCImplSignalingState::SignalingHaveLocalPranswer;
+      newState = RTCSignalingState::Have_local_pranswer;
       break;
     case kJsepStateHaveRemotePranswer:
-      newState = PCImplSignalingState::SignalingHaveRemotePranswer;
+      newState = RTCSignalingState::Have_remote_pranswer;
       break;
     case kJsepStateClosed:
-      newState = PCImplSignalingState::SignalingClosed;
+      newState = RTCSignalingState::Closed;
       break;
     default:
       MOZ_CRASH();
@@ -2335,7 +2333,7 @@ void PeerConnectionImpl::UpdateSignalingState(bool rollback) {
 }
 
 bool PeerConnectionImpl::IsClosed() const {
-  return mSignalingState == PCImplSignalingState::SignalingClosed;
+  return mSignalingState == RTCSignalingState::Closed;
 }
 
 bool PeerConnectionImpl::HasMedia() const { return mMedia; }
@@ -2437,22 +2435,22 @@ void PeerConnectionImpl::SendLocalIceCandidateToContent(
       NS_DISPATCH_NORMAL);
 }
 
-static bool isDone(PCImplIceConnectionState state) {
-  return state != PCImplIceConnectionState::Checking &&
-         state != PCImplIceConnectionState::New;
+static bool isDone(RTCIceConnectionState state) {
+  return state != RTCIceConnectionState::Checking &&
+         state != RTCIceConnectionState::New;
 }
 
-static bool isSucceeded(PCImplIceConnectionState state) {
-  return state == PCImplIceConnectionState::Connected ||
-         state == PCImplIceConnectionState::Completed;
+static bool isSucceeded(RTCIceConnectionState state) {
+  return state == RTCIceConnectionState::Connected ||
+         state == RTCIceConnectionState::Completed;
 }
 
-static bool isFailed(PCImplIceConnectionState state) {
-  return state == PCImplIceConnectionState::Failed;
+static bool isFailed(RTCIceConnectionState state) {
+  return state == RTCIceConnectionState::Failed;
 }
 
 void PeerConnectionImpl::IceConnectionStateChange(
-    dom::PCImplIceConnectionState domState) {
+    dom::RTCIceConnectionState domState) {
   PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
 
   CSFLogDebug(LOGTAG, "%s: %d", __FUNCTION__, static_cast<int>(domState));
@@ -2479,7 +2477,7 @@ void PeerConnectionImpl::IceConnectionStateChange(
 
   // Uncount this connection as active on the inner window upon close.
   if (mWindow && mActiveOnWindow &&
-      mIceConnectionState == PCImplIceConnectionState::Closed) {
+      mIceConnectionState == RTCIceConnectionState::Closed) {
     mWindow->RemovePeerConnection();
     mActiveOnWindow = false;
   }
@@ -2487,27 +2485,27 @@ void PeerConnectionImpl::IceConnectionStateChange(
   // Would be nice if we had a means of converting one of these dom enums
   // to a string that wasn't almost as much text as this switch statement...
   switch (mIceConnectionState) {
-    case PCImplIceConnectionState::New:
+    case RTCIceConnectionState::New:
       STAMP_TIMECARD(mTimeCard, "Ice state: new");
       break;
-    case PCImplIceConnectionState::Checking:
+    case RTCIceConnectionState::Checking:
       // For telemetry
       mIceStartTime = TimeStamp::Now();
       STAMP_TIMECARD(mTimeCard, "Ice state: checking");
       break;
-    case PCImplIceConnectionState::Connected:
+    case RTCIceConnectionState::Connected:
       STAMP_TIMECARD(mTimeCard, "Ice state: connected");
       break;
-    case PCImplIceConnectionState::Completed:
+    case RTCIceConnectionState::Completed:
       STAMP_TIMECARD(mTimeCard, "Ice state: completed");
       break;
-    case PCImplIceConnectionState::Failed:
+    case RTCIceConnectionState::Failed:
       STAMP_TIMECARD(mTimeCard, "Ice state: failed");
       break;
-    case PCImplIceConnectionState::Disconnected:
+    case RTCIceConnectionState::Disconnected:
       STAMP_TIMECARD(mTimeCard, "Ice state: disconnected");
       break;
-    case PCImplIceConnectionState::Closed:
+    case RTCIceConnectionState::Closed:
       STAMP_TIMECARD(mTimeCard, "Ice state: closed");
       break;
     default:
@@ -2519,7 +2517,7 @@ void PeerConnectionImpl::IceConnectionStateChange(
 }
 
 void PeerConnectionImpl::IceGatheringStateChange(
-    dom::PCImplIceGatheringState state) {
+    dom::RTCIceGatheringState state) {
   PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
 
   CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
@@ -2529,13 +2527,13 @@ void PeerConnectionImpl::IceGatheringStateChange(
   // Would be nice if we had a means of converting one of these dom enums
   // to a string that wasn't almost as much text as this switch statement...
   switch (mIceGatheringState) {
-    case PCImplIceGatheringState::New:
+    case RTCIceGatheringState::New:
       STAMP_TIMECARD(mTimeCard, "Ice gathering state: new");
       break;
-    case PCImplIceGatheringState::Gathering:
+    case RTCIceGatheringState::Gathering:
       STAMP_TIMECARD(mTimeCard, "Ice gathering state: gathering");
       break;
-    case PCImplIceGatheringState::Complete:
+    case RTCIceGatheringState::Complete:
       STAMP_TIMECARD(mTimeCard, "Ice gathering state: complete");
       break;
     default:
@@ -2549,7 +2547,7 @@ void PeerConnectionImpl::IceGatheringStateChange(
                    static_cast<JS::Realm*>(nullptr)),
       NS_DISPATCH_NORMAL);
 
-  if (mIceGatheringState == PCImplIceGatheringState::Complete) {
+  if (mIceGatheringState == RTCIceGatheringState::Complete) {
     SendLocalIceCandidateToContent(0, "", "", "");
   }
 }

media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h

@@ -32,7 +32,6 @@
 #include "signaling/src/sdp/SdpMediaSection.h"
 
 #include "mozilla/ErrorResult.h"
-#include "mozilla/dom/PeerConnectionImplEnumsBinding.h"
 #include "mozilla/dom/RTCPeerConnectionBinding.h"  // mozPacketDumpType, maybe move?
 #include "mozilla/dom/RTCRtpTransceiverBinding.h"
 #include "mozilla/dom/RTCConfigurationBinding.h"
@@ -206,8 +205,8 @@ class PeerConnectionImpl final
   virtual const std::string& GetName();
 
   // ICE events
-  void IceConnectionStateChange(dom::PCImplIceConnectionState state);
-  void IceGatheringStateChange(dom::PCImplIceGatheringState state);
+  void IceConnectionStateChange(dom::RTCIceConnectionState state);
+  void IceGatheringStateChange(dom::RTCIceGatheringState state);
   void UpdateDefaultCandidate(const std::string& defaultAddr,
                               uint16_t defaultPort,
                               const std::string& defaultRtcpAddr,
@@ -414,28 +413,26 @@ class PeerConnectionImpl final
   void GetCurrentRemoteDescription(nsAString& aSDP);
   void GetPendingRemoteDescription(nsAString& aSDP);
 
-  NS_IMETHODIMP SignalingState(mozilla::dom::PCImplSignalingState* aState);
+  NS_IMETHODIMP SignalingState(mozilla::dom::RTCSignalingState* aState);
 
-  mozilla::dom::PCImplSignalingState SignalingState() {
-    mozilla::dom::PCImplSignalingState state;
+  mozilla::dom::RTCSignalingState SignalingState() {
+    mozilla::dom::RTCSignalingState state;
     SignalingState(&state);
     return state;
   }
 
-  NS_IMETHODIMP IceConnectionState(
-      mozilla::dom::PCImplIceConnectionState* aState);
+  NS_IMETHODIMP IceConnectionState(mozilla::dom::RTCIceConnectionState* aState);
 
-  mozilla::dom::PCImplIceConnectionState IceConnectionState() {
-    mozilla::dom::PCImplIceConnectionState state;
+  mozilla::dom::RTCIceConnectionState IceConnectionState() {
+    mozilla::dom::RTCIceConnectionState state;
     IceConnectionState(&state);
     return state;
   }
 
-  NS_IMETHODIMP IceGatheringState(
-      mozilla::dom::PCImplIceGatheringState* aState);
+  NS_IMETHODIMP IceGatheringState(mozilla::dom::RTCIceGatheringState* aState);
 
-  mozilla::dom::PCImplIceGatheringState IceGatheringState() {
-    mozilla::dom::PCImplIceGatheringState state;
+  mozilla::dom::RTCIceGatheringState IceGatheringState() {
+    mozilla::dom::RTCIceGatheringState state;
     IceGatheringState(&state);
     return state;
   }
@@ -471,7 +468,7 @@ class PeerConnectionImpl final
   const std::vector<std::string>& GetSdpParseErrors();
 
   // Sets the RTC Signaling State
-  void SetSignalingState_m(mozilla::dom::PCImplSignalingState aSignalingState,
+  void SetSignalingState_m(mozilla::dom::RTCSignalingState aSignalingState,
                            bool rollback = false);
 
   // Updates the RTC signaling state based on the JsepSession state
@@ -576,11 +573,11 @@ class PeerConnectionImpl final
   // any other attributes of this class.
   Timecard* mTimeCard;
 
-  mozilla::dom::PCImplSignalingState mSignalingState;
+  mozilla::dom::RTCSignalingState mSignalingState;
 
   // ICE State
-  mozilla::dom::PCImplIceConnectionState mIceConnectionState;
-  mozilla::dom::PCImplIceGatheringState mIceGatheringState;
+  mozilla::dom::RTCIceConnectionState mIceConnectionState;
+  mozilla::dom::RTCIceGatheringState mIceGatheringState;
 
   nsCOMPtr<nsIThread> mThread;
   RefPtr<PeerConnectionObserver> mPCObserver;

media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp

@@ -96,8 +96,7 @@ void PeerConnectionMedia::StunAddrsHandler::OnStunAddrsAvailable(
     // If parent process returns 0 STUN addresses, change ICE connection
     // state to failed.
     if (!pcm_->mStunAddrs.Length()) {
-      pcm_->SignalIceConnectionStateChange(
-          dom::PCImplIceConnectionState::Failed);
+      pcm_->SignalIceConnectionStateChange(dom::RTCIceConnectionState::Failed);
     }
 
     pcm_ = nullptr;
@@ -630,7 +629,7 @@ nsresult PeerConnectionMedia::AddRIDFilter(MediaStreamTrack& aRecvTrack,
 }
 
 void PeerConnectionMedia::IceGatheringStateChange_s(
-    dom::PCImplIceGatheringState aState) {
+    dom::RTCIceGatheringState aState) {
   ASSERT_ON_THREAD(mSTSThread);
 
   // ShutdownMediaTransport_s has not run yet because it unhooks this function
@@ -644,7 +643,7 @@ void PeerConnectionMedia::IceGatheringStateChange_s(
 }
 
 void PeerConnectionMedia::IceConnectionStateChange_s(
-    dom::PCImplIceConnectionState aState) {
+    dom::RTCIceConnectionState aState) {
   ASSERT_ON_THREAD(mSTSThread);
   // ShutdownMediaTransport_s has not run yet because it unhooks this function
   // from its signal, which means that SelfDestruct_m has not been dispatched
@@ -676,13 +675,13 @@ void PeerConnectionMedia::OnCandidateFound_s(
 }
 
 void PeerConnectionMedia::IceGatheringStateChange_m(
-    dom::PCImplIceGatheringState aState) {
+    dom::RTCIceGatheringState aState) {
   ASSERT_ON_THREAD(mMainThread);
   SignalIceGatheringStateChange(aState);
 }
 
 void PeerConnectionMedia::IceConnectionStateChange_m(
-    dom::PCImplIceConnectionState aState) {
+    dom::RTCIceConnectionState aState) {
   ASSERT_ON_THREAD(mMainThread);
   SignalIceConnectionStateChange(aState);
 }

media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h

@@ -131,9 +131,9 @@ class PeerConnectionMedia : public sigslot::has_slots<> {
                                const std::string& aAlpn);
 
   // ICE state signals
-  sigslot::signal1<mozilla::dom::PCImplIceGatheringState>
+  sigslot::signal1<mozilla::dom::RTCIceGatheringState>
       SignalIceGatheringStateChange;
-  sigslot::signal1<mozilla::dom::PCImplIceConnectionState>
+  sigslot::signal1<mozilla::dom::RTCIceConnectionState>
       SignalIceConnectionStateChange;
   // This passes a candidate:... attribute, transport id, and ufrag
   // end-of-candidates is signaled with the empty string
@@ -201,13 +201,13 @@ class PeerConnectionMedia : public sigslot::has_slots<> {
   void ConnectSignals();
 
   // ICE events
-  void IceGatheringStateChange_s(dom::PCImplIceGatheringState aState);
-  void IceConnectionStateChange_s(dom::PCImplIceConnectionState aState);
+  void IceGatheringStateChange_s(dom::RTCIceGatheringState aState);
+  void IceConnectionStateChange_s(dom::RTCIceConnectionState aState);
   void OnCandidateFound_s(const std::string& aTransportId,
                           const CandidateInfo& aCandidateInfo);
 
-  void IceGatheringStateChange_m(dom::PCImplIceGatheringState aState);
-  void IceConnectionStateChange_m(dom::PCImplIceConnectionState aState);
+  void IceGatheringStateChange_m(dom::RTCIceGatheringState aState);
+  void IceConnectionStateChange_m(dom::RTCIceConnectionState aState);
   void OnCandidateFound_m(const std::string& aTransportId,
                           const CandidateInfo& aCandidateInfo);
 

media/webrtc/signaling/src/peerconnection/WebrtcGlobalInformation.cpp

@@ -1044,7 +1044,7 @@ void WebrtcGlobalInformation::StoreLongTermICEStatistics(
   Telemetry::Accumulate(Telemetry::WEBRTC_ICE_FINAL_CONNECTION_STATE,
                         static_cast<uint32_t>(aPc.IceConnectionState()));
 
-  if (aPc.IceConnectionState() == PCImplIceConnectionState::New) {
+  if (aPc.IceConnectionState() == RTCIceConnectionState::New) {
     // ICE has not started; we won't have any remote candidates, so recording
     // statistics on gathered candidates is pointless.
     return;