Use all stun addresses in PepperPortAllocator.

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 33 matching lines @@
   virtual void GetPortConfigurations() OVERRIDE;
   virtual void SendSessionRequest(const std::string& host, int port) OVERRIDE;
 
  private:
   void OnUrlOpened(int32_t result);
   void ReadResponseBody();
   void OnResponseBodyRead(int32_t result);
 
   pp::InstanceHandle instance_;
 
-  rtc::SocketAddress stun_address_;
-  int stun_port_;
+  cricket::ServerAddresses stun_hosts_;
 
   scoped_ptr<pp::URLLoader> relay_url_loader_;
   std::vector<char> relay_response_body_;
   bool relay_response_received_;
 
   pp::CompletionCallbackFactory<PepperPortAllocatorSession> callback_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PepperPortAllocatorSession);
 };
 
@@ skipping 10 matching lines @@
     : HttpPortAllocatorSessionBase(allocator,
                                    content_name,
                                    component,
                                    ice_username_fragment,
                                    ice_password,
                                    stun_hosts,
                                    relay_hosts,
                                    relay_token,
                                    std::string()),
       instance_(instance),
-      stun_port_(0),
+      stun_hosts_(stun_hosts.begin(), stun_hosts.end()),
       relay_response_received_(false),
       callback_factory_(this) {
-  if (stun_hosts.size() > 0) {
-    stun_address_ = stun_hosts[0];
-  }
 }
 
 PepperPortAllocatorSession::~PepperPortAllocatorSession() {
 }
 
 void PepperPortAllocatorSession::ConfigReady(
     cricket::PortConfiguration* config) {
   // 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 a configuration without relay response first so local and STUN
   // candidates can be allocated without waiting for the relay response.
   ConfigReady(new cricket::PortConfiguration(
-      stun_address_, std::string(), std::string()));
+      stun_hosts_, std::string(), std::string()));
 
   TryCreateRelaySession();
 }
 
 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) +
@@ skipping 116 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