Support multiple STUN servers for PeerConnection.

remoting/client/plugin/pepper_port_allocator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/client/plugin/pepper_port_allocator.h"
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/net_util.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 85 matching lines @@
   if (stun_hosts.size() > 0) {
     stun_address_ = stun_hosts[0];
   }
 }
 
 PepperPortAllocatorSession::~PepperPortAllocatorSession() {
 }
 
 void PepperPortAllocatorSession::ConfigReady(
     cricket::PortConfiguration* config) {
-  if (config->stun_address.IsUnresolved()) {
+  if (!config->stun_servers.empty() &&

[Sergey Ulanov, 2014/08/08 19:57:16]

FYI: there is https://codereview.chromium.org/452923005/ that will conflict with
this change.

+      config->stun_servers.begin()->IsUnresolved()) {
     // Make sure that the address that we pass to ConfigReady() is
     // always resolved.
-    if (stun_address_.IsUnresolved()) {
-      config->stun_address.Clear();
-    } else {
-      config->stun_address = stun_address_;
-    }
+    config->stun_servers.clear();
+    if (!stun_address_.IsUnresolved())
+      config->stun_servers.insert(stun_address_);
   }
 
   // Filter out non-UDP relay ports, so that we don't try using TCP.
   for (cricket::PortConfiguration::RelayList::iterator relay =
            config->relays.begin(); relay != config->relays.end(); ++relay) {
     cricket::PortList filtered_ports;
     for (cricket::PortList::iterator port =
              relay->ports.begin(); port != relay->ports.end(); ++port) {
       if (port->proto == cricket::PROTO_UDP) {
         filtered_ports.push_back(*port);
       }
     }
     relay->ports = filtered_ports;
   }
   cricket::BasicPortAllocatorSession::ConfigReady(config);
 }
 
 void PepperPortAllocatorSession::GetPortConfigurations() {
   // Add an empty configuration synchronously, so a local connection
   // can be started immediately.
   ConfigReady(new cricket::PortConfiguration(
-      rtc::SocketAddress(), std::string(), std::string()));
+      cricket::ServerAddresses(), std::string(), std::string()));
 
   ResolveStunServerAddress();
   TryCreateRelaySession();
 }
 
 void PepperPortAllocatorSession::ResolveStunServerAddress() {
   if (stun_address_.IsNil()) {
     return;
   }
 
@@ skipping 45 matching lines @@
     // and Relay parameters are stored together in PortConfiguration
     // and ReceiveSessionResponse() doesn't save relay session
     // configuration for the case we resolve STUN address later. This
     // method invokes overriden ConfigReady() which then submits
     // resolved |stun_address_|.
     //
     // TODO(sergeyu): Refactor HttpPortAllocatorSessionBase to fix this.
     ReceiveSessionResponse(std::string(relay_response_body_.begin(),
                                        relay_response_body_.end()));
   } else {
+    cricket::ServerAddresses stun;
+    stun.insert(stun_address_);
     ConfigReady(new cricket::PortConfiguration(
-        stun_address_, std::string(), std::string()));
+        stun, std::string(), std::string()));
   }
 }
 
 void PepperPortAllocatorSession::SendSessionRequest(
     const std::string& host,
     int port) {
   relay_url_loader_.reset(new pp::URLLoader(instance_));
   pp::URLRequestInfo request_info(instance_);
   std::string url = "https://" + host + ":" + base::IntToString(port) +
       GetSessionRequestUrl() + "&sn=1";
@@ skipping 115 matching lines @@
     const std::string& content_name,
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password) {
    return new PepperPortAllocatorSession(
        this, content_name, component, ice_username_fragment, ice_password,
        stun_hosts(), relay_hosts(), relay_token(), instance_);
 }
 
 }  // namespace remoting