Add TransportContext class.

remoting/host/remoting_me2me_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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 45 matching lines @@
 #include "remoting/host/host_main.h"
 #include "remoting/host/host_status_logger.h"
 #include "remoting/host/input_injector.h"
 #include "remoting/host/ipc_desktop_environment.h"
 #include "remoting/host/ipc_host_event_logger.h"
 #include "remoting/host/logging.h"
 #include "remoting/host/me2me_desktop_environment.h"
 #include "remoting/host/oauth_token_getter_impl.h"
 #include "remoting/host/pairing_registry_delegate.h"
 #include "remoting/host/policy_watcher.h"
-#include "remoting/host/session_manager_factory.h"
 #include "remoting/host/shutdown_watchdog.h"
 #include "remoting/host/signaling_connector.h"
 #include "remoting/host/single_window_desktop_environment.h"
 #include "remoting/host/switches.h"
 #include "remoting/host/third_party_auth_config.h"
 #include "remoting/host/token_validator_factory_impl.h"
 #include "remoting/host/usage_stats_consent.h"
 #include "remoting/host/username.h"
 #include "remoting/host/video_frame_recorder_host_extension.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/channel_authenticator.h"
-#include "remoting/protocol/chromium_port_allocator_factory.h"
+#include "remoting/protocol/chromium_port_allocator.h"
+#include "remoting/protocol/ice_transport.h"
 #include "remoting/protocol/jingle_session_manager.h"
 #include "remoting/protocol/me2me_host_authenticator_factory.h"
 #include "remoting/protocol/network_settings.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "remoting/protocol/port_range.h"
 #include "remoting/protocol/token_validator.h"
+#include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/webrtc_transport.h"
 #include "remoting/signaling/push_notification_subscriber.h"
 #include "remoting/signaling/xmpp_signal_strategy.h"
 #include "third_party/webrtc/base/scoped_ref_ptr.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include "base/file_descriptor_posix.h"
@@ skipping 1394 matching lines @@
   if (!udp_port_range_.is_null()) {
     network_settings.port_range = udp_port_range_;
   } else if (!allow_nat_traversal_) {
     // For legacy reasons we have to restrict the port range to a set of default
     // values when nat traversal is disabled, even if the port range was not
     // set in policy.
     network_settings.port_range.min_port = NetworkSettings::kDefaultMinPort;
     network_settings.port_range.max_port = NetworkSettings::kDefaultMaxPort;
   }
 
-  scoped_ptr<protocol::SessionManager> session_manager;
+  scoped_refptr<protocol::TransportContext> transport_context =
+      new protocol::TransportContext(
+          signal_strategy_.get(),
+          make_scoped_ptr(new protocol::ChromiumPortAllocatorFactory(
+              context_->url_request_context_getter())),
+          network_settings, protocol::TransportRole::SERVER);
+  scoped_ptr<protocol::TransportFactory> transport_factory;
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kEnableWebrtc)) {
 #if !defined(NDEBUG)
-    network_settings.flags = protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING;
-
-    scoped_ptr<protocol::PortAllocatorFactory> port_allocator_factory =
-        protocol::ChromiumPortAllocatorFactory::Create(
-            network_settings, context_->url_request_context_getter());
-
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
     // The network thread is also used as worker thread for webrtc.
     //
     // TODO(sergeyu): Figure out if we would benefit from using a separate
     // thread as a worker thread.
-    scoped_ptr<protocol::TransportFactory> transport_factory(
-        new protocol::WebrtcTransportFactory(
-            jingle_glue::JingleThreadWrapper::current(), signal_strategy_.get(),
-            std::move(port_allocator_factory),
-            protocol::TransportRole::SERVER));
-
-    session_manager.reset(
-        new protocol::JingleSessionManager(transport_factory.Pass()));
+    transport_factory.reset(new protocol::WebrtcTransportFactory(
+        jingle_glue::JingleThreadWrapper::current(), transport_context));
 #else  // !defined(NDEBUG)
     LOG(ERROR) << "WebRTC is enabled only in debug builds.";
     ShutdownHost(kUsageExitCode);
     return;
 #endif  // defined(NDEBUG)
   } else {
-    session_manager =
-        CreateHostSessionManager(signal_strategy_.get(), network_settings,
-                                 context_->url_request_context_getter());
+    transport_factory.reset(
+        new protocol::IceTransportFactory(transport_context));
   }
+  scoped_ptr<protocol::SessionManager> session_manager(
+      new protocol::JingleSessionManager(transport_factory.Pass()));
 
   scoped_ptr<protocol::CandidateSessionConfig> protocol_config =
       protocol::CandidateSessionConfig::CreateDefault();
   if (!desktop_environment_factory_->SupportsAudioCapture())
     protocol_config->DisableAudioChannel();
   if (enable_vp9_)
     protocol_config->set_vp9_experiment_enabled(true);
 #if !defined(NDEBUG)
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(kEnableWebrtc)) {
     protocol_config->set_webrtc_supported(true);
@@ skipping 209 matching lines @@
       base::TimeDelta::FromSeconds(kShutdownTimeoutSeconds));
   new HostProcess(context.Pass(), &exit_code, &shutdown_watchdog);
 
   // Run the main (also UI) message loop until the host no longer needs it.
   message_loop.Run();
 
   return exit_code;
 }
 
 }  // namespace remoting