Resolve addresses of STUN/Relay servers in JingleInfoRequest.

remoting/protocol/jingle_session_manager.cc

 // Copyright (c) 2011 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/protocol/jingle_session_manager.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "remoting/base/constants.h"
+#include "remoting/jingle_glue/host_address_resolver.h"
 #include "remoting/jingle_glue/http_port_allocator.h"
 #include "remoting/jingle_glue/jingle_info_request.h"
 #include "remoting/jingle_glue/jingle_signaling_connector.h"
 #include "remoting/jingle_glue/signal_strategy.h"
 #include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
 #include "third_party/libjingle/source/talk/p2p/base/sessionmanager.h"
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
 #include "third_party/libjingle/source/talk/p2p/base/constants.h"
 #include "third_party/libjingle/source/talk/p2p/base/transport.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 // static
 JingleSessionManager* JingleSessionManager::CreateNotSandboxed() {
-  return new JingleSessionManager(NULL, NULL, NULL);
+  return new JingleSessionManager(NULL, NULL, NULL, NULL);
 }
 
 // static
 JingleSessionManager* JingleSessionManager::CreateSandboxed(
     talk_base::NetworkManager* network_manager,
     talk_base::PacketSocketFactory* socket_factory,
+    HostAddressResolver* host_address_resolver,
     PortAllocatorSessionFactory* port_allocator_session_factory) {
   return new JingleSessionManager(network_manager, socket_factory,
+                                  host_address_resolver,
                                   port_allocator_session_factory);
 }
 
 JingleSessionManager::JingleSessionManager(
     talk_base::NetworkManager* network_manager,
     talk_base::PacketSocketFactory* socket_factory,
+    HostAddressResolver* host_address_resolver,
     PortAllocatorSessionFactory* port_allocator_session_factory)
     : network_manager_(network_manager),
       socket_factory_(socket_factory),
+      host_address_resolver_(host_address_resolver),
       port_allocator_session_factory_(port_allocator_session_factory),
       signal_strategy_(NULL),
       allow_nat_traversal_(false),
       allow_local_ips_(false),
       http_port_allocator_(NULL),
       closed_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
 }
 
 JingleSessionManager::~JingleSessionManager() {
@@ skipping 54 matching lines @@
   cricket_session_manager_.reset(
       new cricket::SessionManager(port_allocator_.get()));
   cricket_session_manager_->AddClient(kChromotingXmlNamespace, this);
 
   jingle_signaling_connector_.reset(new JingleSignalingConnector(
       signal_strategy_, cricket_session_manager_.get()));
 
   // If NAT traversal is enabled then we need to request STUN/Relay info.
   if (allow_nat_traversal) {
     jingle_info_request_.reset(
-        new JingleInfoRequest(signal_strategy_->CreateIqRequest()));
+        new JingleInfoRequest(signal_strategy_->CreateIqRequest(),
+                              host_address_resolver_.get()));
     jingle_info_request_->Send(base::Bind(
         &JingleSessionManager::OnJingleInfo, base::Unretained(this)));
   } else {
     listener_->OnSessionManagerInitialized();
   }
 }
 
 void JingleSessionManager::Close() {
   DCHECK(CalledOnValidThread());
 
@@ skipping 206 matching lines @@
     const std::string& certificate) {
   cricket::SessionDescription* desc = new cricket::SessionDescription();
   desc->AddContent(
       JingleSession::kChromotingContentName, kChromotingXmlNamespace,
       new ContentDescription(config, "", "", certificate));
   return desc;
 }
 
 }  // namespace protocol
 }  // namespace remoting