Set incoming_only flag on the host side when NAT traversal is disabled.

remoting/protocol/jingle_session_manager.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/protocol/jingle_session_manager.h"
 
 #include "base/bind.h"
 #include "remoting/jingle_glue/iq_sender.h"
 #include "remoting/jingle_glue/jingle_info_request.h"
 #include "remoting/jingle_glue/signal_strategy.h"
@@ skipping 22 matching lines @@
 }
 
 void JingleSessionManager::Init(
     SignalStrategy* signal_strategy,
     SessionManager::Listener* listener,
     const NetworkSettings& network_settings) {
   listener_ = listener;
   signal_strategy_ = signal_strategy;
   iq_sender_.reset(new IqSender(signal_strategy_));
 
-  transport_config_.nat_traversal = network_settings.allow_nat_traversal;
+  transport_config_.nat_traversal_mode =
+      network_settings.allow_nat_traversal ?
+      TransportConfig::NAT_TRAVERSAL_ENABLED :
+      TransportConfig::NAT_TRAVERSAL_DISABLED;
   transport_config_.min_port = network_settings.min_port;
   transport_config_.max_port = network_settings.max_port;
 
   signal_strategy_->AddListener(this);
 
   OnSignalStrategyStateChange(signal_strategy_->GetState());
 }
 
 void JingleSessionManager::OnJingleInfo(
     const std::string& relay_token,
@@ skipping 46 matching lines @@
 void JingleSessionManager::set_authenticator_factory(
     scoped_ptr<AuthenticatorFactory> authenticator_factory) {
   DCHECK(CalledOnValidThread());
   authenticator_factory_ = authenticator_factory.Pass();
 }
 
 void JingleSessionManager::OnSignalStrategyStateChange(
     SignalStrategy::State state) {
   // If NAT traversal is enabled then we need to request STUN/Relay info.
   if (state == SignalStrategy::CONNECTED) {
-    if (transport_config_.nat_traversal) {
+    if (transport_config_.nat_traversal_mode ==
+        TransportConfig::NAT_TRAVERSAL_ENABLED) {
       jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_));
       jingle_info_request_->Send(base::Bind(&JingleSessionManager::OnJingleInfo,
                                             base::Unretained(this)));
     } else if (!ready_) {
       ready_ = true;
       listener_->OnSessionManagerReady();
     }
   }
 }
 
@@ skipping 53 matching lines @@
   signal_strategy_->SendStanza(
       JingleMessageReply(error).ToXml(original_stanza));
 }
 
 void JingleSessionManager::SessionDestroyed(JingleSession* session) {
   sessions_.erase(session->session_id_);
 }
 
 }  // namespace protocol
 }  // namespace remoting