Updates RTCIceTransport to standard state API.

The underlying P2PTransportChannel has been updated to the spec
compliant RTCIceTransportState. This change updates the standalone
RTCIceTransport to use this.

Bug: 928081
Change-Id: Ia127c0f5473e49b8c48e8595f8381aa2542e7e2e
Reviewed-on: https://chromium-review.googlesource.com/c/1483943Reviewed-by: Steve Anton <steveanton@chromium.org>
Commit-Queue: Seth Hampson <shampson@chromium.org>
Cr-Commit-Position: refs/heads/master@{#635652}

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_adapter.h

@@ -46,7 +46,7 @@ class IceTransportAdapter {
     virtual void OnCandidateGathered(const cricket::Candidate& candidate) {}
 
     // Called asynchronously when the ICE connection state has changed.
-    virtual void OnStateChanged(cricket::IceTransportState new_state) {}
+    virtual void OnStateChanged(webrtc::IceTransportState new_state) {}
 
     // Called asynchronously when the ICE agent selects a different candidate
     // pair for the active connection.

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_adapter_impl.cc

@@ -38,7 +38,7 @@ IceTransportAdapterImpl::IceTransportAdapterImpl(
       this, &IceTransportAdapterImpl::OnGatheringStateChanged);
   p2p_transport_channel()->SignalCandidateGathered.connect(
       this, &IceTransportAdapterImpl::OnCandidateGathered);
-  p2p_transport_channel()->SignalStateChanged.connect(
+  p2p_transport_channel()->SignalIceTransportStateChanged.connect(
       this, &IceTransportAdapterImpl::OnStateChanged);
   p2p_transport_channel()->SignalNetworkRouteChanged.connect(
       this, &IceTransportAdapterImpl::OnNetworkRouteChanged);
@@ -129,7 +129,7 @@ void IceTransportAdapterImpl::OnCandidateGathered(
 void IceTransportAdapterImpl::OnStateChanged(
     cricket::IceTransportInternal* transport) {
   DCHECK_EQ(transport, p2p_transport_channel());
-  delegate_->OnStateChanged(p2p_transport_channel()->GetState());
+  delegate_->OnStateChanged(p2p_transport_channel()->GetIceTransportState());
 }
 
 void IceTransportAdapterImpl::OnNetworkRouteChanged(

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_host.cc

@@ -117,7 +117,7 @@ void IceTransportHost::OnCandidateGathered(
                                       proxy_, candidate));
 }
 
-void IceTransportHost::OnStateChanged(cricket::IceTransportState new_state) {
+void IceTransportHost::OnStateChanged(webrtc::IceTransportState new_state) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   PostCrossThreadTask(
       *proxy_thread_, FROM_HERE,

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_host.h

@@ -76,7 +76,7 @@ class IceTransportHost final : public IceTransportAdapter::Delegate {
   // IceTransportAdapter::Delegate overrides.
   void OnGatheringStateChanged(cricket::IceGatheringState new_state) override;
   void OnCandidateGathered(const cricket::Candidate& candidate) override;
-  void OnStateChanged(cricket::IceTransportState new_state) override;
+  void OnStateChanged(webrtc::IceTransportState new_state) override;
   void OnSelectedCandidatePairChanged(
       const std::pair<cricket::Candidate, cricket::Candidate>&
           selected_candidate_pair) override;

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_proxy.cc

@@ -136,7 +136,7 @@ void IceTransportProxy::OnCandidateGathered(
   delegate_->OnCandidateGathered(candidate);
 }
 
-void IceTransportProxy::OnStateChanged(cricket::IceTransportState new_state) {
+void IceTransportProxy::OnStateChanged(webrtc::IceTransportState new_state) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   delegate_->OnStateChanged(new_state);
 }

third_party/blink/renderer/modules/peerconnection/adapters/ice_transport_proxy.h

@@ -53,7 +53,7 @@ class IceTransportProxy final {
     virtual void OnGatheringStateChanged(cricket::IceGatheringState new_state) {
     }
     virtual void OnCandidateGathered(const cricket::Candidate& candidate) {}
-    virtual void OnStateChanged(cricket::IceTransportState new_state) {}
+    virtual void OnStateChanged(webrtc::IceTransportState new_state) {}
     virtual void OnSelectedCandidatePairChanged(
         const std::pair<cricket::Candidate, cricket::Candidate>&
             selected_candidate_pair) {}
@@ -100,7 +100,7 @@ class IceTransportProxy final {
   friend class IceTransportHost;
   void OnGatheringStateChanged(cricket::IceGatheringState new_state);
   void OnCandidateGathered(const cricket::Candidate& candidate);
-  void OnStateChanged(cricket::IceTransportState new_state);
+  void OnStateChanged(webrtc::IceTransportState new_state);
   void OnSelectedCandidatePairChanged(
       const std::pair<cricket::Candidate, cricket::Candidate>&
           selected_candidate_pair);

third_party/blink/renderer/modules/peerconnection/rtc_ice_transport.cc

@@ -169,19 +169,19 @@ String RTCIceTransport::role() const {
 
 String RTCIceTransport::state() const {
   switch (state_) {
-    case RTCIceTransportState::kNew:
+    case webrtc::IceTransportState::kNew:
       return "new";
-    case RTCIceTransportState::kChecking:
+    case webrtc::IceTransportState::kChecking:
       return "checking";
-    case RTCIceTransportState::kConnected:
+    case webrtc::IceTransportState::kConnected:
       return "connected";
-    case RTCIceTransportState::kCompleted:
+    case webrtc::IceTransportState::kCompleted:
       return "completed";
-    case RTCIceTransportState::kDisconnected:
+    case webrtc::IceTransportState::kDisconnected:
       return "disconnected";
-    case RTCIceTransportState::kFailed:
+    case webrtc::IceTransportState::kFailed:
       return "failed";
-    case RTCIceTransportState::kClosed:
+    case webrtc::IceTransportState::kClosed:
       return "closed";
   }
   NOTREACHED();
@@ -352,7 +352,7 @@ void RTCIceTransport::start(RTCIceParameters* remote_parameters,
     // Calling start() for the first time.
     role_ = role;
     if (remote_candidates_.size() > 0) {
-      state_ = RTCIceTransportState::kChecking;
+      state_ = webrtc::IceTransportState::kChecking;
     }
     std::vector<cricket::Candidate> initial_remote_candidates;
     for (RTCIceCandidate* remote_candidate : remote_candidates_) {
@@ -368,7 +368,7 @@ void RTCIceTransport::start(RTCIceParameters* remote_parameters,
     }
   } else {
     remote_candidates_.clear();
-    state_ = RTCIceTransportState::kNew;
+    state_ = webrtc::IceTransportState::kNew;
     proxy_->HandleRemoteRestart(ConvertIceParameters(remote_parameters));
   }
 
@@ -397,7 +397,7 @@ void RTCIceTransport::addRemoteCandidate(RTCIceCandidate* remote_candidate,
   remote_candidates_.push_back(remote_candidate);
   if (remote_parameters_) {
     proxy_->AddRemoteCandidate(*converted_remote_candidate);
-    state_ = RTCIceTransportState::kChecking;
+    state_ = webrtc::IceTransportState::kChecking;
   }
 }
 
@@ -433,30 +433,12 @@ void RTCIceTransport::OnCandidateGathered(
       event_type_names::kIcecandidate, event_init));
 }
 
-static RTCIceTransportState ConvertIceTransportState(
-    cricket::IceTransportState state) {
-  switch (state) {
-    case cricket::IceTransportState::STATE_INIT:
-      return RTCIceTransportState::kNew;
-    case cricket::IceTransportState::STATE_CONNECTING:
-      return RTCIceTransportState::kChecking;
-    case cricket::IceTransportState::STATE_COMPLETED:
-      return RTCIceTransportState::kConnected;
-    case cricket::IceTransportState::STATE_FAILED:
-      return RTCIceTransportState::kFailed;
-    default:
-      NOTREACHED();
-      return RTCIceTransportState::kClosed;
-  }
-}
-
-void RTCIceTransport::OnStateChanged(cricket::IceTransportState new_state) {
-  RTCIceTransportState local_new_state = ConvertIceTransportState(new_state);
-  if (local_new_state == state_) {
+void RTCIceTransport::OnStateChanged(webrtc::IceTransportState new_state) {
+  if (new_state == state_) {
     return;
   }
-  state_ = local_new_state;
-  if (state_ == RTCIceTransportState::kFailed) {
+  state_ = new_state;
+  if (state_ == webrtc::IceTransportState::kFailed) {
     selected_candidate_pair_ = nullptr;
   }
   DispatchEvent(*Event::Create(event_type_names::kStatechange));
@@ -476,13 +458,13 @@ void RTCIceTransport::OnSelectedCandidatePairChanged(
 }
 
 void RTCIceTransport::Close(CloseReason reason) {
-  DCHECK_NE(state_, RTCIceTransportState::kClosed);
+  DCHECK_NE(state_, webrtc::IceTransportState::kClosed);
   if (HasConsumer()) {
     consumer_->OnIceTransportClosed(reason);
   }
   // Notifying the consumer that we're closing should cause it to disconnect.
   DCHECK(!HasConsumer());
-  state_ = RTCIceTransportState::kClosed;
+  state_ = webrtc::IceTransportState::kClosed;
   selected_candidate_pair_ = nullptr;
   proxy_.reset();
 }

third_party/blink/renderer/modules/peerconnection/rtc_ice_transport.h

@@ -13,6 +13,7 @@
 #include "third_party/blink/renderer/modules/peerconnection/rtc_ice_candidate_pair.h"
 #include "third_party/blink/renderer/modules/peerconnection/rtc_ice_parameters.h"
 #include "third_party/blink/renderer/platform/scheduler/public/frame_scheduler.h"
+#include "third_party/webrtc/api/transport/enums.h"
 
 namespace blink {
 
@@ -22,16 +23,6 @@ class RTCIceGatherOptions;
 class IceTransportAdapterCrossThreadFactory;
 class RTCQuicTransport;
 
-enum class RTCIceTransportState {
-  kNew,
-  kChecking,
-  kConnected,
-  kCompleted,
-  kDisconnected,
-  kFailed,
-  kClosed
-};
-
 // Blink bindings for the RTCIceTransport JavaScript object.
 //
 // This class uses the IceTransportProxy to run and interact with the WebRTC
@@ -78,7 +69,7 @@ class MODULES_EXPORT RTCIceTransport final
   cricket::IceRole GetRole() const { return role_; }
 
   // Returns true if the RTCIceTransport is in a terminal state.
-  bool IsClosed() const { return state_ == RTCIceTransportState::kClosed; }
+  bool IsClosed() const { return state_ == webrtc::IceTransportState::kClosed; }
 
   // An RTCQuicTransport can be connected to this RTCIceTransport. Only one can
   // be connected at a time. The consumer will be automatically disconnected
@@ -130,7 +121,7 @@ class MODULES_EXPORT RTCIceTransport final
   // IceTransportProxy::Delegate overrides.
   void OnGatheringStateChanged(cricket::IceGatheringState new_state) override;
   void OnCandidateGathered(const cricket::Candidate& candidate) override;
-  void OnStateChanged(cricket::IceTransportState new_state) override;
+  void OnStateChanged(webrtc::IceTransportState new_state) override;
   void OnSelectedCandidatePairChanged(
       const std::pair<cricket::Candidate, cricket::Candidate>&
           selected_candidate_pair) override;
@@ -147,7 +138,7 @@ class MODULES_EXPORT RTCIceTransport final
   bool RaiseExceptionIfClosed(ExceptionState& exception_state) const;
 
   cricket::IceRole role_ = cricket::ICEROLE_UNKNOWN;
-  RTCIceTransportState state_ = RTCIceTransportState::kNew;
+  webrtc::IceTransportState state_ = webrtc::IceTransportState::kNew;
   cricket::IceGatheringState gathering_state_ = cricket::kIceGatheringNew;
 
   HeapVector<Member<RTCIceCandidate>> local_candidates_;

third_party/blink/renderer/modules/peerconnection/rtc_ice_transport_test.cc

@@ -320,10 +320,10 @@ TEST_F(RTCIceTransportTest, RemoteCandidatesNotPassedUntilStartCalled) {
                        ASSERT_NO_EXCEPTION);
 }
 
-// Test that receiving an OnStateChanged callback with the completed state
+// Test that receiving an OnStateChanged callback with the connected state
 // updates the RTCIceTransport state to 'connected' and fires a statechange
 // event.
-TEST_F(RTCIceTransportTest, OnStateChangedCompletedUpdatesStateAndFiresEvent) {
+TEST_F(RTCIceTransportTest, OnStateChangedConnectedUpdatesStateAndFiresEvent) {
   V8TestingScope scope;
 
   IceTransportAdapter::Delegate* delegate = nullptr;
@@ -347,11 +347,76 @@ TEST_F(RTCIceTransportTest, OnStateChangedCompletedUpdatesStateAndFiresEvent) {
   delegate->OnCandidateGathered(
       CricketCandidateFromString(kLocalIceCandidateStr1));
 
-  delegate->OnStateChanged(cricket::IceTransportState::STATE_COMPLETED);
+  delegate->OnStateChanged(webrtc::IceTransportState::kConnected);
 
   RunUntilIdle();
 }
 
+// Test that receiving an OnStateChanged callback with the completed state
+// updates the RTCIceTransport state to 'completed' and fires a statechange
+// event.
+TEST_F(RTCIceTransportTest, OnStateChangedCompletedUpdatesStateAndFiresEvent) {
+  V8TestingScope scope;
+
+  IceTransportAdapter::Delegate* delegate = nullptr;
+  Persistent<RTCIceTransport> ice_transport =
+      CreateIceTransport(scope, &delegate);
+  ice_transport->start(CreateRemoteRTCIceParameters1(), "controlling",
+                       ASSERT_NO_EXCEPTION);
+  RunUntilIdle();
+  ASSERT_TRUE(delegate);
+
+  Persistent<MockEventListener> event_listener = CreateMockEventListener();
+  EXPECT_CALL(*event_listener, Invoke(_, _))
+      .WillOnce(InvokeWithoutArgs(
+          [ice_transport] { EXPECT_EQ("completed", ice_transport->state()); }));
+  ice_transport->addEventListener(event_type_names::kStatechange,
+                                  event_listener);
+
+  ice_transport->addRemoteCandidate(
+      RTCIceCandidateFromString(scope, kRemoteIceCandidateStr1),
+      ASSERT_NO_EXCEPTION);
+  delegate->OnCandidateGathered(
+      CricketCandidateFromString(kLocalIceCandidateStr1));
+
+  delegate->OnStateChanged(webrtc::IceTransportState::kCompleted);
+
+  RunUntilIdle();
+}
+
+// Test that receiving an OnStateChanged callback with the disconnected state
+// updates the RTCIceTransport state to 'disconnected' and fires a statechange
+// event.
+TEST_F(RTCIceTransportTest,
+       OnStateChangedDisconnectedUpdatesStateAndFiresEvent) {
+  V8TestingScope scope;
+
+  IceTransportAdapter::Delegate* delegate = nullptr;
+  Persistent<RTCIceTransport> ice_transport =
+      CreateIceTransport(scope, &delegate);
+  ice_transport->start(CreateRemoteRTCIceParameters1(), "controlling",
+                       ASSERT_NO_EXCEPTION);
+  RunUntilIdle();
+  ASSERT_TRUE(delegate);
+
+  Persistent<MockEventListener> event_listener = CreateMockEventListener();
+  EXPECT_CALL(*event_listener, Invoke(_, _))
+      .WillOnce(InvokeWithoutArgs([ice_transport] {
+        EXPECT_EQ("disconnected", ice_transport->state());
+      }));
+  ice_transport->addEventListener(event_type_names::kStatechange,
+                                  event_listener);
+
+  ice_transport->addRemoteCandidate(
+      RTCIceCandidateFromString(scope, kRemoteIceCandidateStr1),
+      ASSERT_NO_EXCEPTION);
+  delegate->OnCandidateGathered(
+      CricketCandidateFromString(kLocalIceCandidateStr1));
+
+  delegate->OnStateChanged(webrtc::IceTransportState::kDisconnected);
+
+  RunUntilIdle();
+}
 // Test that receiving an OnStateChanged callback with the failed state updates
 // the RTCIceTransport state to 'failed' and fires a statechange event.
 TEST_F(RTCIceTransportTest, OnStateChangedFailedUpdatesStateAndFiresEvent) {
@@ -378,7 +443,7 @@ TEST_F(RTCIceTransportTest, OnStateChangedFailedUpdatesStateAndFiresEvent) {
   delegate->OnCandidateGathered(
       CricketCandidateFromString(kLocalIceCandidateStr1));
 
-  delegate->OnStateChanged(cricket::IceTransportState::STATE_FAILED);
+  delegate->OnStateChanged(webrtc::IceTransportState::kFailed);
 
   RunUntilIdle();
 }
@@ -513,13 +578,13 @@ TEST_F(RTCIceTransportTest,
       ASSERT_NO_EXCEPTION);
   delegate->OnCandidateGathered(
       CricketCandidateFromString(kLocalIceCandidateStr1));
-  delegate->OnStateChanged(cricket::IceTransportState::STATE_COMPLETED);
+  delegate->OnStateChanged(webrtc::IceTransportState::kConnected);
   delegate->OnSelectedCandidatePairChanged(
       std::make_pair(CricketCandidateFromString(kLocalIceCandidateStr1),
                      CricketCandidateFromString(kRemoteIceCandidateStr1)));
 
   // Transition to failed.
-  delegate->OnStateChanged(cricket::IceTransportState::STATE_FAILED);
+  delegate->OnStateChanged(webrtc::IceTransportState::kFailed);
 
   RunUntilIdle();
 }
@@ -565,7 +630,7 @@ TEST_F(RTCIceTransportTest,
   // effect.
   delegate->OnCandidateGathered(
       CricketCandidateFromString(kLocalIceCandidateStr1));
-  delegate->OnStateChanged(cricket::IceTransportState::STATE_COMPLETED);
+  delegate->OnStateChanged(webrtc::IceTransportState::kConnected);
   delegate->OnSelectedCandidatePairChanged(
       std::make_pair(CricketCandidateFromString(kLocalIceCandidateStr1),
                      CricketCandidateFromString(kRemoteIceCandidateStr1)));

third_party/blink/web_tests/external/wpt/webrtc/RTCIceTransport-extension.https.html

@@ -260,7 +260,7 @@ promise_test(async t => {
     const [ localTransport, remoteTransport ] =
         makeAndGatherTwoIceTransports(t);
     localTransport.start(remoteTransport.getLocalParameters(), role);
-    localTransport.start(remoteTransport.getLocalParameters(), role);
+    remoteTransport.start(localTransport.getLocalParameters(), role);
     const localWatcher = new EventWatcher(t, localTransport, 'statechange');
     const remoteWatcher = new EventWatcher(t, remoteTransport, 'statechange');
     await Promise.all([
@@ -276,13 +276,10 @@ promise_test(async t => {
 });
 
 promise_test(async t => {
-  async function waitForConnectedThenSelectedCandidatePairChange(t, transport,
+  async function waitForSelectedCandidatePairChangeThenConnected(t, transport,
       transportName) {
     const watcher = new EventWatcher(t, transport,
         [ 'statechange', 'selectedcandidatepairchange' ]);
-    await watcher.wait_for('statechange');
-    assert_equals(transport.state, 'connected',
-        `${transportName} state should be 'connected'`);
     await watcher.wait_for('selectedcandidatepairchange');
     const selectedCandidatePair = transport.getSelectedCandidatePair();
     assert_not_equals(selectedCandidatePair, null,
@@ -300,13 +297,16 @@ promise_test(async t => {
                 candidate === selectedCandidatePair.remote.candidate),
         `${transportName} selected candidate pair local should be in the ` +
         'list of remote candidates');
+    await watcher.wait_for('statechange');
+    assert_equals(transport.state, 'connected',
+        `${transportName} state should be 'connected'`);
   }
   const [ localTransport, remoteTransport ] =
       makeGatherAndStartTwoIceTransports(t);
   await Promise.all([
-    waitForConnectedThenSelectedCandidatePairChange(t, localTransport,
+    waitForSelectedCandidatePairChangeThenConnected(t, localTransport,
         'local transport'),
-    waitForConnectedThenSelectedCandidatePairChange(t, remoteTransport,
+    waitForSelectedCandidatePairChangeThenConnected(t, remoteTransport,
         'remote transport'),
   ]);
 }, 'Selected candidate pair changes once the RTCIceTransports connect.');