Move the ICE state transition ASSERTS to a lower level.

webrtc/p2p/base/p2ptransportchannel.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 1191 matching lines @@
                                      last_sent_packet_id_);
 }
 
 // Warning: UpdateState should eventually be called whenever a connection
 // is added, deleted, or the write state of any connection changes so that the
 // transport controller will get the up-to-date channel state. However it
 // should not be called too often; in the case that multiple connection states
 // change, it should be called after all the connection states have changed. For
 // example, we call this at the end of SortConnections.
 void P2PTransportChannel::UpdateState() {
+  TransportChannelState old_state = state_;
   state_ = ComputeState();
 
+  if (old_state != state_) {
+    LOG_J(LS_INFO, this) << "Changing TransportChannelState " << old_state
+                         << " => " << state_;
+
+    // Check that the requested transition is allowed. Note that
+    // P2PTransportChannel does not (yet) implement a direct mapping of the ICE
+    // states from the standard; the difference is covered by
+    // TransportController and PeerConnection.
+    switch (old_state) {
+      case STATE_INIT:
+        // TODO(deadbeef): Once we implement end-of-candidates signaling,
+        // we shouldn't go from INIT to COMPLETED.
+        RTC_DCHECK(state_ == STATE_CONNECTING || state_ == STATE_COMPLETED);
+        break;
+      case STATE_CONNECTING:
+        RTC_DCHECK(state_ == STATE_COMPLETED || state_ == STATE_FAILED);
+        break;
+      case STATE_COMPLETED:
+        // TODO(deadbeef): Once we implement end-of-candidates signaling,
+        // we shouldn't go from COMPLETED to CONNECTING.
+        // Though we *can* go from COMPlETED to FAILED, if consent expires.
+        RTC_DCHECK(state_ == STATE_CONNECTING || state_ == STATE_FAILED);
+        break;
+      case STATE_FAILED:
+        // TODO(deadbeef): Once we implement end-of-candidates signaling,
+        // we shouldn't go from FAILED to CONNECTING or COMPLETED.
+        RTC_DCHECK(state_ == STATE_CONNECTING || state_ == STATE_COMPLETED);
+        break;
+      default:
+        RTC_DCHECK(false);
+        break;
+    }
+  }
+
   bool writable = best_connection_ && best_connection_->writable();
   set_writable(writable);
 
   bool receiving = false;
   for (const Connection* connection : connections_) {
     if (connection->receiving()) {
       receiving = true;
       break;
     }
   }
@@ skipping 434 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket