Destroy a Connection if a CreatePermission request fails.

webrtc/p2p/base/turnport.cc

 /*
  *  Copyright 2012 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 427 matching lines @@
   }
 
   // Create an entry, if needed, so we can get our permissions set up correctly.
   CreateEntry(address.address());
 
   // A TURN port will have two candiates, STUN and TURN. STUN may not
   // present in all cases. If present stun candidate will be added first
   // and TURN candidate later.
   for (size_t index = 0; index < Candidates().size(); ++index) {
     if (Candidates()[index].type() == RELAY_PORT_TYPE) {
-      ProxyConnection* conn = new ProxyConnection(this, index, address);
+      TurnConnection* conn = new TurnConnection(this, index, address);
       conn->SignalDestroyed.connect(this, &TurnPort::OnConnectionDestroyed);
       AddConnection(conn);
       return conn;
     }
   }
   return NULL;
 }
 
 int TurnPort::SetOption(rtc::Socket::Option opt, int value) {
   if (!socket_) {
@@ skipping 880 matching lines @@
   port_->SignalCreatePermissionResult(port_, ext_addr_, 0);
 }
 
 void TurnEntry::OnCreatePermissionError(StunMessage* response, int code) {
   if (code == STUN_ERROR_STALE_NONCE) {
     if (port_->UpdateNonce(response)) {
       SendCreatePermissionRequest();
     }
   } else {
     // Send signal with error code.
     port_->SignalCreatePermissionResult(port_, ext_addr_, code);

[juberti, 2015/10/26 21:27:24]

Rather than using the signal, I think it would be simplest to do something like

port_->DestroyConnection(ext_addr_);

Then you don't need a new TURN connection class.

   }
 }
 
 void TurnEntry::OnChannelBindSuccess() {
   LOG_J(LS_INFO, port_) << "Channel bind for " << ext_addr_.ToSensitiveString()
                         << " succeeded";
   ASSERT(state_ == STATE_BINDING || state_ == STATE_BOUND);
   state_ = STATE_BOUND;
 }
 
 void TurnEntry::OnChannelBindError(StunMessage* response, int code) {
   // TODO(mallinath) - Implement handling of error response for channel
   // bind request as per http://tools.ietf.org/html/rfc5766#section-11.3
   if (code == STUN_ERROR_STALE_NONCE) {
     if (port_->UpdateNonce(response)) {
       // Send channel bind request with fresh nonce.
       SendChannelBindRequest(0);
     }
   }
 }
 
+TurnConnection::TurnConnection(TurnPort* port,
+                               size_t index,
+                               const Candidate& remote_candidate)
+    : ProxyConnection(port, index, remote_candidate), turn_port_(port) {
+  turn_port_->SignalCreatePermissionResult.connect(
+      this, &TurnConnection::OnCreatePermissionResult);
+}
+
+TurnConnection::~TurnConnection() {
+  turn_port_->SignalCreatePermissionResult.disconnect(this);
+}
+
+void TurnConnection::OnCreatePermissionResult(
+    TurnPort* port,
+    const rtc::SocketAddress& remote_address,
+    int code) {
+  RTC_DCHECK(port == turn_port_);
+  // If this signal is for another connection, or it's a success, ignore it.
+  if (remote_address != remote_candidate_.address() || code == 0) {
+    return;
+  }
+  LOG_J(LS_ERROR, this) << "Received TURN CreatePermission error response, "
+                        << "code=" << code << "; killing connection.";
+  set_state(STATE_FAILED);
+  Destroy();
+}
+
 }  // namespace cricket