Move PortAllocator creation out of LibjingleTransportFactory.

remoting/host/chromoting_host.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/host/chromoting_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
 #include "build/build_config.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/encoder_row_based.h"
 #include "remoting/base/encoder_vp8.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/screen_recorder.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/libjingle_transport_factory.h"
 #include "remoting/protocol/session_config.h"
+#include "third_party/libjingle/source/talk/base/basicpacketsocketfactory.h"
+#include "third_party/libjingle/source/talk/base/network.h"
+#include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
 
 namespace remoting {
 
 namespace {
 
 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
   // Number of initial errors (in sequence) to ignore before applying
@@ skipping 20 matching lines @@
   // Don't use initial delay unless the last request was an error.
   false,
 };
 
 }  // namespace
 
 ChromotingHost::ChromotingHost(
     ChromotingHostContext* context,
     SignalStrategy* signal_strategy,
     DesktopEnvironment* environment,
-    const protocol::NetworkSettings& network_settings)
+    const NetworkSettings& network_settings)
     : context_(context),
       desktop_environment_(environment),
       network_settings_(network_settings),
       signal_strategy_(signal_strategy),
       stopping_recorders_(0),
       state_(kInitial),
       protocol_config_(protocol::CandidateSessionConfig::CreateDefault()),
       login_backoff_(&kDefaultBackoffPolicy),
       authenticating_client_(false),
       reject_authenticating_client_(false) {
@@ skipping 11 matching lines @@
 void ChromotingHost::Start() {
   DCHECK(context_->network_message_loop()->BelongsToCurrentThread());
 
   LOG(INFO) << "Starting host";
 
   // Make sure this object is not started.
   if (state_ != kInitial)
     return;
   state_ = kStarted;
 
+  // Create port allocator.
+  // TODO(sergeyu): Replace the code below with HostPortAllocator when
+  // it is implemented.
+  scoped_ptr<talk_base::NetworkManager> network_manager(
+      new talk_base::BasicNetworkManager());
+  scoped_ptr<talk_base::PacketSocketFactory> socket_factory(
+      new talk_base::BasicPacketSocketFactory());
+  scoped_ptr<cricket::PortAllocator> port_allocator;
+
+  // We always use PseudoTcp to provide a reliable channel. However
+  // when it is used together with TCP the performance is veryey bad

[Wez, 2012/04/27 17:58:51]

typo: veryey

[Sergey Ulanov, 2012/04/27 22:51:14]

Done.

+  // so we explicitly disable TCP connections.

[Wez, 2012/04/27 17:58:51]

nit: ... disable channels conencting over TCP.

[Sergey Ulanov, 2012/04/27 22:51:14]

Done.

+  int port_allocator_flags = cricket::PORTALLOCATOR_DISABLE_TCP;
+  if (network_settings_.nat_traversal_mode ==
+      NetworkSettings::NAT_TRAVERSAL_ENABLED) {

[Wez, 2012/04/27 17:58:51]

Replace this if/else with a switch, so it's easier to read and we get
compile-time checks on the set of values.

[Sergey Ulanov, 2012/04/27 22:51:14]

In one of my two other CLs this code is moved and changed to a single if without
else, so no need to change it here.

+      port_allocator.reset(new cricket::HttpPortAllocator(
+          network_manager.get(), socket_factory.get(), ""));
+  } else {
+    port_allocator_flags |= cricket::PORTALLOCATOR_DISABLE_STUN |
+        cricket::PORTALLOCATOR_DISABLE_RELAY;
+    port_allocator.reset(
+        new cricket::BasicPortAllocator(network_manager.get(),
+                                        socket_factory.get()));
+  }
+  port_allocator->set_flags(port_allocator_flags);
+  port_allocator->SetPortRange(network_settings_.min_port,
+                               network_settings_.max_port);
+
+  bool incoming_only = network_settings_.nat_traversal_mode ==
+      NetworkSettings::NAT_TRAVERSAL_DISABLED;
+
+  scoped_ptr<protocol::TransportFactory> transport_factory(
+      new protocol::LibjingleTransportFactory(
+          network_manager.Pass(), socket_factory.Pass(),
+          port_allocator.Pass(), incoming_only));
+
   // Create and start session manager.
-  scoped_ptr<protocol::TransportFactory> transport_factory(
-      new protocol::LibjingleTransportFactory());
-  session_manager_.reset(
-      new protocol::JingleSessionManager(transport_factory.Pass()));
-  session_manager_->Init(signal_strategy_, this, network_settings_);
+  bool fetch_stun_relay_info = network_settings_.nat_traversal_mode ==
+      NetworkSettings::NAT_TRAVERSAL_ENABLED;

[Wez, 2012/04/27 17:58:51]

nit: Consider defining this false, before the port-allocator test of
nat_traversal_mode, so that there's just one block defining the
NAT_TRAVERSAL_ENABLED behaviour.

[Sergey Ulanov, 2012/04/27 22:51:14]

This code above is moved to a separate file in one of my other two CLs.

+  session_manager_.reset(new protocol::JingleSessionManager(
+      transport_factory.Pass(), fetch_stun_relay_info));
+  session_manager_->Init(signal_strategy_, this);
 }
 
 // This method is called when we need to destroy the host process.
 void ChromotingHost::Shutdown(const base::Closure& shutdown_task) {
   if (!context_->network_message_loop()->BelongsToCurrentThread()) {
     context_->network_message_loop()->PostTask(
         FROM_HERE, base::Bind(&ChromotingHost::Shutdown, this, shutdown_task));
     return;
   }
 
@@ skipping 296 matching lines @@
                     OnShutdown());
 
   for (std::vector<base::Closure>::iterator it = shutdown_tasks_.begin();
        it != shutdown_tasks_.end(); ++it) {
     it->Run();
   }
   shutdown_tasks_.clear();
 }
 
 }  // namespace remoting