Support a user-provided string for the TLS ALPN extension.

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 203 matching lines @@
 TurnPort::TurnPort(rtc::Thread* thread,
                    rtc::PacketSocketFactory* factory,
                    rtc::Network* network,
                    uint16_t min_port,
                    uint16_t max_port,
                    const std::string& username,
                    const std::string& password,
                    const ProtocolAddress& server_address,
                    const RelayCredentials& credentials,
                    int server_priority,
-                   const std::string& origin)
+                   const std::string& origin,
+                   const std::vector<std::string>& tls_alpn_protocols)
     : Port(thread,
            RELAY_PORT_TYPE,
            factory,
            network,
            min_port,
            max_port,
            username,
            password),
       server_address_(server_address),
+      tls_alpn_protocols_(tls_alpn_protocols),
       credentials_(credentials),
       socket_(NULL),
       resolver_(NULL),
       error_(0),
       request_manager_(thread),
       next_channel_number_(TURN_CHANNEL_NUMBER_START),
       state_(STATE_CONNECTING),
       server_priority_(server_priority),
       allocate_mismatch_retries_(0) {
   request_manager_.SignalSendPacket.connect(this, &TurnPort::OnSendStunPacket);
@@ skipping 85 matching lines @@
     // Apply server address TLS and insecure bits to options.
     if (server_address_.proto == PROTO_TLS) {
       if (tls_cert_policy_ ==
           TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK) {
         opts |= rtc::PacketSocketFactory::OPT_TLS_INSECURE;
       } else {
         opts |= rtc::PacketSocketFactory::OPT_TLS;
       }
     }
 
+    rtc::PacketSocketTcpOptions tcp_options;
+    tcp_options.opts = opts;
+    tcp_options.tls_alpn_protocols = tls_alpn_protocols_;
+//    rtc::PacketSocketTcpOptions tcp_options = {
+//      .opts = opts,
+//      .tls_alpn_protocols = tls_alpn_protocols_
+//    };
     socket_ = socket_factory()->CreateClientTcpSocket(
         rtc::SocketAddress(Network()->GetBestIP(), 0), server_address_.address,
-        proxy(), user_agent(), opts);
+        proxy(), user_agent(), tcp_options);
   }
 
   if (!socket_) {
     error_ = SOCKET_ERROR;
     return false;
   }
 
   // Apply options if any.
   for (SocketOptionsMap::iterator iter = socket_options_.begin();
        iter != socket_options_.end(); ++iter) {
@@ skipping 1241 matching lines @@
   } else {
     state_ = STATE_UNBOUND;
     port_->FailAndPruneConnection(ext_addr_);
   }
 }
 void TurnEntry::OnChannelBindTimeout() {
   state_ = STATE_UNBOUND;
   port_->FailAndPruneConnection(ext_addr_);
 }
 }  // namespace cricket