From 86030f38b4a7be9418c50da7e83ff55749438dba Mon Sep 17 00:00:00 2001 From: sergeyu Date: Wed, 16 Dec 2015 14:45:00 -0800 Subject: Add TransportContext class. The new TransportContext is now used to store all parameters required to initialize Transport objects and is applicable both to IceTransport and WebrtcTransport. It also allowed to reduce amount of boilerplate code when passing around these parameters. BUG=547158 Review URL: https://codereview.chromium.org/1521883006 Cr-Commit-Position: refs/heads/master@{#365649} --- remoting/client/chromoting_client.cc | 8 +- remoting/client/chromoting_client.h | 4 +- remoting/client/jni/chromoting_jni_instance.cc | 20 ++-- remoting/client/plugin/chromoting_instance.cc | 13 ++- remoting/client/plugin/pepper_port_allocator.cc | 21 ++-- remoting/client/plugin/pepper_port_allocator.h | 15 +++ remoting/host/cast_extension_session.cc | 18 +-- remoting/host/it2me/it2me_host.cc | 19 +++- remoting/host/remoting_me2me_host.cc | 36 +++--- remoting/host/session_manager_factory.cc | 36 ------ remoting/host/session_manager_factory.h | 32 ------ remoting/protocol/chromium_port_allocator.cc | 43 +++----- remoting/protocol/chromium_port_allocator.h | 29 ++++- .../protocol/chromium_port_allocator_factory.cc | 39 ------- .../protocol/chromium_port_allocator_factory.h | 47 -------- remoting/protocol/connection_to_host.h | 4 +- remoting/protocol/connection_to_host_impl.cc | 7 +- remoting/protocol/connection_to_host_impl.h | 2 +- remoting/protocol/fake_connection_to_host.cc | 3 +- remoting/protocol/fake_connection_to_host.h | 2 +- remoting/protocol/ice_transport.cc | 41 +++---- remoting/protocol/ice_transport.h | 32 +++--- remoting/protocol/ice_transport_channel.cc | 76 ++++++------- remoting/protocol/ice_transport_channel.h | 22 ++-- remoting/protocol/ice_transport_factory.cc | 93 ---------------- remoting/protocol/ice_transport_factory.h | 61 ----------- remoting/protocol/ice_transport_unittest.cc | 22 ++-- remoting/protocol/jingle_session_unittest.cc | 22 ++-- remoting/protocol/port_allocator_factory.h | 8 +- remoting/protocol/transport_context.cc | 122 +++++++++++++++++++++ remoting/protocol/transport_context.h | 92 ++++++++++++++++ remoting/protocol/webrtc_transport.cc | 51 ++++----- remoting/protocol/webrtc_transport.h | 22 ++-- remoting/protocol/webrtc_transport_unittest.cc | 19 ++-- remoting/remoting_host_srcs.gypi | 2 - remoting/remoting_srcs.gypi | 6 +- remoting/test/fake_port_allocator.cc | 49 ++++----- remoting/test/fake_port_allocator.h | 30 +++-- remoting/test/protocol_perftest.cc | 53 ++++----- remoting/test/test_chromoting_client.cc | 17 ++- 40 files changed, 577 insertions(+), 661 deletions(-) delete mode 100644 remoting/host/session_manager_factory.cc delete mode 100644 remoting/host/session_manager_factory.h delete mode 100644 remoting/protocol/chromium_port_allocator_factory.cc delete mode 100644 remoting/protocol/chromium_port_allocator_factory.h delete mode 100644 remoting/protocol/ice_transport_factory.cc delete mode 100644 remoting/protocol/ice_transport_factory.h create mode 100644 remoting/protocol/transport_context.cc create mode 100644 remoting/protocol/transport_context.h diff --git a/remoting/client/chromoting_client.cc b/remoting/client/chromoting_client.cc index d9e0f37..303150f 100644 --- a/remoting/client/chromoting_client.cc +++ b/remoting/client/chromoting_client.cc @@ -18,7 +18,7 @@ #include "remoting/protocol/host_stub.h" #include "remoting/protocol/negotiating_client_authenticator.h" #include "remoting/protocol/session_config.h" -#include "remoting/protocol/transport.h" +#include "remoting/protocol/transport_context.h" namespace remoting { @@ -56,7 +56,7 @@ void ChromotingClient::SetConnectionToHostForTests( void ChromotingClient::Start( SignalStrategy* signal_strategy, scoped_ptr authenticator, - scoped_ptr transport_factory, + scoped_refptr transport_context, const std::string& host_jid, const std::string& capabilities) { DCHECK(task_runner_->BelongsToCurrentThread()); @@ -68,8 +68,8 @@ void ChromotingClient::Start( connection_->set_video_stub(video_renderer_->GetVideoStub()); connection_->set_audio_stub(audio_decode_scheduler_.get()); - connection_->Connect(signal_strategy, transport_factory.Pass(), - authenticator.Pass(), host_jid, this); + connection_->Connect(signal_strategy, transport_context, authenticator.Pass(), + host_jid, this); } void ChromotingClient::SetCapabilities( diff --git a/remoting/client/chromoting_client.h b/remoting/client/chromoting_client.h index ce7fbcf..93daab2 100644 --- a/remoting/client/chromoting_client.h +++ b/remoting/client/chromoting_client.h @@ -27,7 +27,7 @@ namespace remoting { namespace protocol { class CandidateSessionConfig; -class TransportFactory; +class TransportContext; } // namespace protocol class AudioDecodeScheduler; @@ -62,7 +62,7 @@ class ChromotingClient : public protocol::ConnectionToHost::HostEventCallback, // must outlive the client. void Start(SignalStrategy* signal_strategy, scoped_ptr authenticator, - scoped_ptr transport_factory, + scoped_refptr transport_context, const std::string& host_jid, const std::string& capabilities); diff --git a/remoting/client/jni/chromoting_jni_instance.cc b/remoting/client/jni/chromoting_jni_instance.cc index 0d5314e..535ca0f 100644 --- a/remoting/client/jni/chromoting_jni_instance.cc +++ b/remoting/client/jni/chromoting_jni_instance.cc @@ -21,10 +21,10 @@ #include "remoting/protocol/chromium_port_allocator.h" #include "remoting/protocol/chromium_socket_factory.h" #include "remoting/protocol/host_stub.h" -#include "remoting/protocol/ice_transport_factory.h" #include "remoting/protocol/negotiating_client_authenticator.h" #include "remoting/protocol/network_settings.h" #include "remoting/protocol/performance_tracker.h" +#include "remoting/protocol/transport_context.h" #include "remoting/signaling/server_log_entry.h" #include "ui/events/keycodes/dom/keycode_converter.h" @@ -423,17 +423,17 @@ void ChromotingJniInstance::ConnectToHostOnNetworkThread() { protocol::NetworkSettings::NAT_TRAVERSAL_FULL); // Use Chrome's network stack to allocate ports for peer-to-peer channels. - scoped_ptr port_allocator( - protocol::ChromiumPortAllocator::Create(jni_runtime_->url_requester(), - network_settings)); + scoped_ptr port_allocator_factory( + new protocol::ChromiumPortAllocatorFactory( + jni_runtime_->url_requester())); - scoped_ptr transport_factory( - new protocol::IceTransportFactory( - signaling_.get(), port_allocator.Pass(), network_settings, - protocol::TransportRole::CLIENT)); + scoped_refptr transport_context = + new protocol::TransportContext( + signaling_.get(), port_allocator_factory.Pass(), network_settings, + protocol::TransportRole::CLIENT); - client_->Start(signaling_.get(), authenticator_.Pass(), - transport_factory.Pass(), host_jid_, capabilities_); + client_->Start(signaling_.get(), authenticator_.Pass(), transport_context, + host_jid_, capabilities_); } void ChromotingJniInstance::FetchSecret( diff --git a/remoting/client/plugin/chromoting_instance.cc b/remoting/client/plugin/chromoting_instance.cc index 13fe342..93918de 100644 --- a/remoting/client/plugin/chromoting_instance.cc +++ b/remoting/client/plugin/chromoting_instance.cc @@ -52,7 +52,7 @@ #include "remoting/client/token_fetcher_proxy.h" #include "remoting/protocol/connection_to_host.h" #include "remoting/protocol/host_stub.h" -#include "remoting/protocol/ice_transport_factory.h" +#include "remoting/protocol/transport_context.h" #include "url/gurl.h" namespace remoting { @@ -693,10 +693,11 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) { local_jid, base::Bind(&ChromotingInstance::SendOutgoingIq, weak_factory_.GetWeakPtr()))); - // Create TransportFactory. - scoped_ptr transport_factory( - new protocol::IceTransportFactory( - signal_strategy_.get(), PepperPortAllocator::Create(this).Pass(), + // Create TransportContext. + scoped_refptr transport_context( + new protocol::TransportContext( + signal_strategy_.get(), + make_scoped_ptr(new PepperPortAllocatorFactory(this)), protocol::NetworkSettings( protocol::NetworkSettings::NAT_TRAVERSAL_FULL), protocol::TransportRole::CLIENT)); @@ -731,7 +732,7 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) { // Kick off the connection. client_->Start(signal_strategy_.get(), authenticator.Pass(), - transport_factory.Pass(), host_jid, capabilities); + transport_context, host_jid, capabilities); // Start timer that periodically sends perf stats. stats_update_timer_.Start( diff --git a/remoting/client/plugin/pepper_port_allocator.cc b/remoting/client/plugin/pepper_port_allocator.cc index a601480..11fee075 100644 --- a/remoting/client/plugin/pepper_port_allocator.cc +++ b/remoting/client/plugin/pepper_port_allocator.cc @@ -225,17 +225,9 @@ PepperPortAllocator::PepperPortAllocator( instance_(instance), network_manager_(network_manager.Pass()), socket_factory_(socket_factory.Pass()) { - // TCP transport is disabled becase PseudoTCP works poorly over - // it. ENABLE_SHARED_UFRAG flag is specified so that the same - // username fragment is shared between all candidates for this - // channel. - set_flags(cricket::PORTALLOCATOR_DISABLE_TCP | - cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG| - cricket::PORTALLOCATOR_ENABLE_IPV6); } -PepperPortAllocator::~PepperPortAllocator() { -} +PepperPortAllocator::~PepperPortAllocator() {} cricket::PortAllocatorSession* PepperPortAllocator::CreateSessionInternal( const std::string& content_name, @@ -247,4 +239,15 @@ cricket::PortAllocatorSession* PepperPortAllocator::CreateSessionInternal( stun_hosts(), relay_hosts(), relay_token(), instance_); } +PepperPortAllocatorFactory::PepperPortAllocatorFactory( + const pp::InstanceHandle& instance) + : instance_(instance) {} + +PepperPortAllocatorFactory::~PepperPortAllocatorFactory() {} + +scoped_ptr +PepperPortAllocatorFactory::CreatePortAllocator() { + return PepperPortAllocator::Create(instance_); +} + } // namespace remoting diff --git a/remoting/client/plugin/pepper_port_allocator.h b/remoting/client/plugin/pepper_port_allocator.h index c98c242..76d447b 100644 --- a/remoting/client/plugin/pepper_port_allocator.h +++ b/remoting/client/plugin/pepper_port_allocator.h @@ -8,6 +8,7 @@ #include "base/compiler_specific.h" #include "base/memory/scoped_ptr.h" #include "ppapi/cpp/instance_handle.h" +#include "remoting/protocol/port_allocator_factory.h" #include "third_party/webrtc/p2p/client/httpportallocator.h" namespace remoting { @@ -47,6 +48,20 @@ class PepperPortAllocator : public cricket::HttpPortAllocatorBase { DISALLOW_COPY_AND_ASSIGN(PepperPortAllocator); }; +class PepperPortAllocatorFactory : public protocol::PortAllocatorFactory { + public: + PepperPortAllocatorFactory(const pp::InstanceHandle& instance); + ~PepperPortAllocatorFactory() override; + + // PortAllocatorFactory interface. + scoped_ptr CreatePortAllocator() override; + + private: + pp::InstanceHandle instance_; + + DISALLOW_COPY_AND_ASSIGN(PepperPortAllocatorFactory); +}; + } // namespace remoting #endif // REMOTING_CLIENT_PLUGIN_PEPPER_PORT_ALLOCATOR_H_ diff --git a/remoting/host/cast_extension_session.cc b/remoting/host/cast_extension_session.cc index 9e4b12d..31087c3 100644 --- a/remoting/host/cast_extension_session.cc +++ b/remoting/host/cast_extension_session.cc @@ -49,11 +49,6 @@ const char kWebRtcSDPMLineIndex[] = "sdpMLineIndex"; const char kVideoLabel[] = "cast_video_label"; const char kStreamLabel[] = "stream_label"; -// Default STUN server used to construct -// ChromiumPortAllocator for the PeerConnection. -const char kDefaultStunHost[] = "stun.l.google.com"; -const int kDefaultStunPort = 19302; - const char kWorkerThreadName[] = "CastExtensionSessionWorkerThread"; // Interval between each call to PollPeerConnectionStats(). @@ -491,17 +486,14 @@ bool CastExtensionSession::InitializePeerConnection() { constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, webrtc::MediaConstraintsInterface::kValueTrue); - rtc::scoped_ptr port_allocator( - protocol::ChromiumPortAllocator::Create(url_request_context_getter_, - network_settings_) - .release()); - std::vector stun_hosts; - stun_hosts.push_back(rtc::SocketAddress(kDefaultStunHost, kDefaultStunPort)); - port_allocator->SetStunHosts(stun_hosts); + scoped_ptr port_allocator = + protocol::ChromiumPortAllocator::Create(url_request_context_getter_); webrtc::PeerConnectionInterface::RTCConfiguration rtc_config; peer_connection_ = peer_conn_factory_->CreatePeerConnection( - rtc_config, &constraints, port_allocator.Pass(), nullptr, this); + rtc_config, &constraints, + rtc::scoped_ptr(port_allocator.release()), + nullptr, this); if (!peer_connection_.get()) { CleanupPeerConnection(); diff --git a/remoting/host/it2me/it2me_host.cc b/remoting/host/it2me/it2me_host.cc index ed1ce1c..0ecec5b 100644 --- a/remoting/host/it2me/it2me_host.cc +++ b/remoting/host/it2me/it2me_host.cc @@ -9,6 +9,7 @@ #include "base/strings/string_util.h" #include "base/threading/platform_thread.h" #include "net/socket/client_socket_factory.h" +#include "net/url_request/url_request_context_getter.h" #include "policy/policy_constants.h" #include "remoting/base/auto_thread.h" #include "remoting/base/logging.h" @@ -22,9 +23,12 @@ #include "remoting/host/it2me_desktop_environment.h" #include "remoting/host/policy_watcher.h" #include "remoting/host/register_support_host_request.h" -#include "remoting/host/session_manager_factory.h" +#include "remoting/protocol/chromium_port_allocator.h" +#include "remoting/protocol/ice_transport.h" #include "remoting/protocol/it2me_host_authenticator_factory.h" +#include "remoting/protocol/jingle_session_manager.h" #include "remoting/protocol/network_settings.h" +#include "remoting/protocol/transport_context.h" #include "remoting/signaling/server_log_entry.h" namespace remoting { @@ -227,9 +231,16 @@ void It2MeHost::FinishConnect() { protocol::NetworkSettings::kDefaultMaxPort; } - scoped_ptr session_manager = - CreateHostSessionManager(signal_strategy_.get(), network_settings, - host_context_->url_request_context_getter()); + scoped_ptr transport_factory( + new protocol::IceTransportFactory(new protocol::TransportContext( + signal_strategy_.get(), + make_scoped_ptr(new protocol::ChromiumPortAllocatorFactory( + host_context_->url_request_context_getter())), + network_settings, protocol::TransportRole::SERVER))); + + scoped_ptr session_manager( + new protocol::JingleSessionManager(transport_factory.Pass())); + scoped_ptr protocol_config = protocol::CandidateSessionConfig::CreateDefault(); // Disable audio by default. diff --git a/remoting/host/remoting_me2me_host.cc b/remoting/host/remoting_me2me_host.cc index 124c768..7e668d4 100644 --- a/remoting/host/remoting_me2me_host.cc +++ b/remoting/host/remoting_me2me_host.cc @@ -63,7 +63,6 @@ #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" @@ -75,13 +74,15 @@ #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" @@ -1496,39 +1497,34 @@ void HostProcess::StartHost() { network_settings.port_range.max_port = NetworkSettings::kDefaultMaxPort; } - scoped_ptr session_manager; + scoped_refptr 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 transport_factory; if (base::CommandLine::ForCurrentProcess()->HasSwitch(kEnableWebrtc)) { #if !defined(NDEBUG) - network_settings.flags = protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING; - - scoped_ptr 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 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 session_manager( + new protocol::JingleSessionManager(transport_factory.Pass())); scoped_ptr protocol_config = protocol::CandidateSessionConfig::CreateDefault(); diff --git a/remoting/host/session_manager_factory.cc b/remoting/host/session_manager_factory.cc deleted file mode 100644 index 58a6752..0000000 --- a/remoting/host/session_manager_factory.cc +++ /dev/null @@ -1,36 +0,0 @@ -// 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/session_manager_factory.h" - -#include "remoting/protocol/chromium_port_allocator.h" -#include "remoting/protocol/chromium_socket_factory.h" -#include "remoting/protocol/ice_transport_factory.h" -#include "remoting/protocol/jingle_session_manager.h" -#include "remoting/protocol/network_settings.h" -#include "remoting/protocol/session_manager.h" - -namespace remoting { - -scoped_ptr CreateHostSessionManager( - SignalStrategy* signal_strategy, - const protocol::NetworkSettings& network_settings, - const scoped_refptr& - url_request_context_getter) { - // Use Chrome's network stack to allocate ports for peer-to-peer channels. - scoped_ptr port_allocator( - protocol::ChromiumPortAllocator::Create(url_request_context_getter, - network_settings)); - - scoped_ptr transport_factory( - new protocol::IceTransportFactory( - signal_strategy, port_allocator.Pass(), network_settings, - protocol::TransportRole::SERVER)); - - scoped_ptr session_manager( - new protocol::JingleSessionManager(transport_factory.Pass())); - return session_manager.Pass(); -} - -} // namespace remoting diff --git a/remoting/host/session_manager_factory.h b/remoting/host/session_manager_factory.h deleted file mode 100644 index 4bce1f6..0000000 --- a/remoting/host/session_manager_factory.h +++ /dev/null @@ -1,32 +0,0 @@ -// 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. - -#ifndef REMOTING_HOST_SESSION_MANAGER_FACTORY_H_ -#define REMOTING_HOST_SESSION_MANAGER_FACTORY_H_ - -#include "base/memory/scoped_ptr.h" -#include "net/url_request/url_request_context_getter.h" - -namespace net { -class URLRequestContextGetter; -} // namespace net - -namespace remoting { - -class SignalStrategy; - -namespace protocol { -struct NetworkSettings; -class SessionManager; -} // namespace protocol - -scoped_ptr CreateHostSessionManager( - SignalStrategy* signal_strategy, - const protocol::NetworkSettings& network_settings, - const scoped_refptr& - url_request_context_getter); - -} // namespace remoting - -#endif // REMOTING_HOST_SESSION_MANAGER_FACTORY_H_ diff --git a/remoting/protocol/chromium_port_allocator.cc b/remoting/protocol/chromium_port_allocator.cc index ffe6756..5a5c103 100644 --- a/remoting/protocol/chromium_port_allocator.cc +++ b/remoting/protocol/chromium_port_allocator.cc @@ -12,7 +12,6 @@ #include "net/url_request/url_fetcher_delegate.h" #include "net/url_request/url_request_context_getter.h" #include "remoting/protocol/chromium_socket_factory.h" -#include "remoting/protocol/network_settings.h" #include "url/gurl.h" namespace remoting { @@ -131,35 +130,13 @@ void ChromiumPortAllocatorSession::OnURLFetchComplete( // static scoped_ptr ChromiumPortAllocator::Create( - const scoped_refptr& url_context, - const NetworkSettings& network_settings) { + const scoped_refptr& url_context) { scoped_ptr network_manager( new rtc::BasicNetworkManager()); scoped_ptr socket_factory( new ChromiumPacketSocketFactory()); - scoped_ptr result( - new ChromiumPortAllocator(url_context, network_manager.Pass(), - socket_factory.Pass())); - - // We always use PseudoTcp to provide a reliable channel. It provides poor - // performance when combined with TCP-based transport, so we have to disable - // TCP ports. ENABLE_SHARED_UFRAG flag is specified so that the same username - // fragment is shared between all candidates for this channel. - int flags = cricket::PORTALLOCATOR_DISABLE_TCP | - cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | - cricket::PORTALLOCATOR_ENABLE_IPV6; - - if (!(network_settings.flags & NetworkSettings::NAT_TRAVERSAL_STUN)) - flags |= cricket::PORTALLOCATOR_DISABLE_STUN; - - if (!(network_settings.flags & NetworkSettings::NAT_TRAVERSAL_RELAY)) - flags |= cricket::PORTALLOCATOR_DISABLE_RELAY; - - result->set_flags(flags); - result->SetPortRange(network_settings.port_range.min_port, - network_settings.port_range.max_port); - - return result.Pass(); + return make_scoped_ptr(new ChromiumPortAllocator( + url_context, network_manager.Pass(), socket_factory.Pass())); } ChromiumPortAllocator::ChromiumPortAllocator( @@ -173,8 +150,7 @@ ChromiumPortAllocator::ChromiumPortAllocator( network_manager_(network_manager.Pass()), socket_factory_(socket_factory.Pass()) {} -ChromiumPortAllocator::~ChromiumPortAllocator() { -} +ChromiumPortAllocator::~ChromiumPortAllocator() {} cricket::PortAllocatorSession* ChromiumPortAllocator::CreateSessionInternal( const std::string& content_name, @@ -186,5 +162,16 @@ cricket::PortAllocatorSession* ChromiumPortAllocator::CreateSessionInternal( stun_hosts(), relay_hosts(), relay_token(), url_context_); } +ChromiumPortAllocatorFactory::ChromiumPortAllocatorFactory( + scoped_refptr url_request_context_getter) + : url_request_context_getter_(url_request_context_getter) {} + +ChromiumPortAllocatorFactory::~ChromiumPortAllocatorFactory() {} + +scoped_ptr +ChromiumPortAllocatorFactory::CreatePortAllocator() { + return ChromiumPortAllocator::Create(url_request_context_getter_); +} + } // namespace protocol } // namespace remoting diff --git a/remoting/protocol/chromium_port_allocator.h b/remoting/protocol/chromium_port_allocator.h index 021000e..65d5799 100644 --- a/remoting/protocol/chromium_port_allocator.h +++ b/remoting/protocol/chromium_port_allocator.h @@ -9,22 +9,24 @@ #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" -#include "net/url_request/url_request_context_getter.h" +#include "remoting/protocol/port_allocator_factory.h" #include "third_party/webrtc/p2p/client/httpportallocator.h" +namespace net { +class URLRequestContextGetter; +} // namespace net + namespace remoting { namespace protocol { struct NetworkSettings; -// An implementation of cricket::PortAllocator for libjingle that -// uses Chromium's network stack and configures itself according -// to the specified NetworkSettings. +// An implementation of cricket::PortAllocator that uses Chromium's network +// stack. class ChromiumPortAllocator : public cricket::HttpPortAllocatorBase { public: static scoped_ptr Create( - const scoped_refptr& url_context, - const NetworkSettings& network_settings); + const scoped_refptr& url_context); ~ChromiumPortAllocator() override; @@ -48,6 +50,21 @@ class ChromiumPortAllocator : public cricket::HttpPortAllocatorBase { DISALLOW_COPY_AND_ASSIGN(ChromiumPortAllocator); }; +class ChromiumPortAllocatorFactory : public PortAllocatorFactory { + public: + ChromiumPortAllocatorFactory( + scoped_refptr url_request_context_getter); + ~ChromiumPortAllocatorFactory() override; + + // PortAllocatorFactory interface. + scoped_ptr CreatePortAllocator() override; + + private: + scoped_refptr url_request_context_getter_; + + DISALLOW_COPY_AND_ASSIGN(ChromiumPortAllocatorFactory); +}; + } // namespace protocol } // namespace remoting diff --git a/remoting/protocol/chromium_port_allocator_factory.cc b/remoting/protocol/chromium_port_allocator_factory.cc deleted file mode 100644 index 32c980b..0000000 --- a/remoting/protocol/chromium_port_allocator_factory.cc +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2015 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/chromium_port_allocator_factory.h" - -#include "base/logging.h" -#include "net/url_request/url_request_context_getter.h" -#include "remoting/protocol/chromium_port_allocator.h" -#include "remoting/protocol/network_settings.h" - -namespace remoting { -namespace protocol { - -ChromiumPortAllocatorFactory::ChromiumPortAllocatorFactory( - const NetworkSettings& network_settings, - scoped_refptr url_request_context_getter) - : network_settings_(network_settings), - url_request_context_getter_(url_request_context_getter) {} - -ChromiumPortAllocatorFactory::~ChromiumPortAllocatorFactory() {} - -scoped_ptr ChromiumPortAllocatorFactory::Create( - const NetworkSettings& network_settings, - scoped_refptr url_request_context_getter) { - return scoped_ptr(new ChromiumPortAllocatorFactory( - network_settings, url_request_context_getter)); -} - -cricket::PortAllocator* ChromiumPortAllocatorFactory::CreatePortAllocator() { - scoped_ptr port_allocator( - ChromiumPortAllocator::Create(url_request_context_getter_, - network_settings_)); - return port_allocator.release(); -} - -} // namespace protocol -} // namespace remoting - diff --git a/remoting/protocol/chromium_port_allocator_factory.h b/remoting/protocol/chromium_port_allocator_factory.h deleted file mode 100644 index 4c7db57..0000000 --- a/remoting/protocol/chromium_port_allocator_factory.h +++ /dev/null @@ -1,47 +0,0 @@ -// Copyright 2015 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. - -#ifndef REMOTING_PROTOCOL_CHROMIUM_PORT_ALLOCATOR_FACTORY_H_ -#define REMOTING_PROTOCOL_CHROMIUM_PORT_ALLOCATOR_FACTORY_H_ - -#include "base/macros.h" -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" -#include "remoting/protocol/network_settings.h" -#include "remoting/protocol/port_allocator_factory.h" - -namespace net { -class URLRequestContextGetter; -} // namespace net - -namespace remoting { -namespace protocol { - -class ChromiumPortAllocatorFactory : public PortAllocatorFactory { - public: - static scoped_ptr Create( - const NetworkSettings& network_settings, - scoped_refptr url_request_context_getter); - - // PortAllocatorFactory implementation. - cricket::PortAllocator* CreatePortAllocator() override; - - protected: - ChromiumPortAllocatorFactory( - const NetworkSettings& network_settings, - scoped_refptr url_request_context_getter); - ~ChromiumPortAllocatorFactory() override; - - private: - NetworkSettings network_settings_; - scoped_refptr url_request_context_getter_; - - DISALLOW_COPY_AND_ASSIGN(ChromiumPortAllocatorFactory); -}; - -} // namespace protocol -} // namespace remoting - -#endif // REMOTING_PROTOCOL_CHROMIUM_PORT_ALLOCATOR_FACTORY_H_ - diff --git a/remoting/protocol/connection_to_host.h b/remoting/protocol/connection_to_host.h index ad9c8ba..f5c8c82 100644 --- a/remoting/protocol/connection_to_host.h +++ b/remoting/protocol/connection_to_host.h @@ -27,7 +27,7 @@ class ExtensionMessage; class HostStub; class InputStub; class SessionConfig; -class TransportFactory; +class TransportContext; struct TransportRoute; class VideoStub; @@ -92,7 +92,7 @@ class ConnectionToHost { // and must outlive the ConnectionToHost. // Caller must set stubs (see below) before calling Connect. virtual void Connect(SignalStrategy* signal_strategy, - scoped_ptr transport_factory, + scoped_refptr transport_context, scoped_ptr authenticator, const std::string& host_jid, HostEventCallback* event_callback) = 0; diff --git a/remoting/protocol/connection_to_host_impl.cc b/remoting/protocol/connection_to_host_impl.cc index fbfdb30..bcca1b0 100644 --- a/remoting/protocol/connection_to_host_impl.cc +++ b/remoting/protocol/connection_to_host_impl.cc @@ -18,8 +18,10 @@ #include "remoting/protocol/client_video_dispatcher.h" #include "remoting/protocol/clipboard_stub.h" #include "remoting/protocol/errors.h" +#include "remoting/protocol/ice_transport.h" #include "remoting/protocol/jingle_session_manager.h" #include "remoting/protocol/transport.h" +#include "remoting/protocol/transport_context.h" #include "remoting/protocol/video_stub.h" namespace remoting { @@ -66,7 +68,7 @@ const char* ConnectionToHost::StateToString(State state) { void ConnectionToHostImpl::Connect( SignalStrategy* signal_strategy, - scoped_ptr transport_factory, + scoped_refptr transport_context, scoped_ptr authenticator, const std::string& host_jid, HostEventCallback* event_callback) { @@ -91,7 +93,8 @@ void ConnectionToHostImpl::Connect( signal_strategy_->AddListener(this); - session_manager_.reset(new JingleSessionManager(transport_factory.Pass())); + session_manager_.reset(new JingleSessionManager( + make_scoped_ptr(new IceTransportFactory(transport_context)))); session_manager_->set_protocol_config(candidate_config_->Clone()); session_manager_->Init(signal_strategy_, this); diff --git a/remoting/protocol/connection_to_host_impl.h b/remoting/protocol/connection_to_host_impl.h index 936d583..9ee9687 100644 --- a/remoting/protocol/connection_to_host_impl.h +++ b/remoting/protocol/connection_to_host_impl.h @@ -54,7 +54,7 @@ class ConnectionToHostImpl : public ConnectionToHost, void set_video_stub(VideoStub* video_stub) override; void set_audio_stub(AudioStub* audio_stub) override; void Connect(SignalStrategy* signal_strategy, - scoped_ptr transport_factory, + scoped_refptr transport_context, scoped_ptr authenticator, const std::string& host_jid, HostEventCallback* event_callback) override; diff --git a/remoting/protocol/fake_connection_to_host.cc b/remoting/protocol/fake_connection_to_host.cc index 2983596..865b61c 100644 --- a/remoting/protocol/fake_connection_to_host.cc +++ b/remoting/protocol/fake_connection_to_host.cc @@ -5,6 +5,7 @@ #include "remoting/protocol/fake_connection_to_host.h" #include "remoting/protocol/authenticator.h" +#include "remoting/protocol/transport_context.h" namespace remoting { namespace test { @@ -36,7 +37,7 @@ void FakeConnectionToHost::set_audio_stub(protocol::AudioStub* audio_stub) { void FakeConnectionToHost::Connect( SignalStrategy* signal_strategy, - scoped_ptr transport_factory, + scoped_refptr transport_context, scoped_ptr authenticator, const std::string& host_jid, HostEventCallback* event_callback) { diff --git a/remoting/protocol/fake_connection_to_host.h b/remoting/protocol/fake_connection_to_host.h index 1c3fe40..85ea24a 100644 --- a/remoting/protocol/fake_connection_to_host.h +++ b/remoting/protocol/fake_connection_to_host.h @@ -26,7 +26,7 @@ class FakeConnectionToHost : public protocol::ConnectionToHost { void set_video_stub(protocol::VideoStub* video_stub) override; void set_audio_stub(protocol::AudioStub* audio_stub) override; void Connect(SignalStrategy* signal_strategy, - scoped_ptr transport_factory, + scoped_refptr transport_context, scoped_ptr authenticator, const std::string& host_jid, HostEventCallback* event_callback) override; diff --git a/remoting/protocol/ice_transport.cc b/remoting/protocol/ice_transport.cc index 8984dd2..08e95d3 100644 --- a/remoting/protocol/ice_transport.cc +++ b/remoting/protocol/ice_transport.cc @@ -10,6 +10,7 @@ #include "remoting/protocol/pseudotcp_channel_factory.h" #include "remoting/protocol/secure_channel_factory.h" #include "remoting/protocol/stream_channel_factory.h" +#include "remoting/protocol/transport_context.h" namespace remoting { namespace protocol { @@ -22,24 +23,16 @@ const int kTransportInfoSendDelayMs = 20; // Name of the multiplexed channel. static const char kMuxChannelName[] = "mux"; -IceTransport::IceTransport(cricket::PortAllocator* port_allocator, - const NetworkSettings& network_settings, - TransportRole role) - : port_allocator_(port_allocator), - network_settings_(network_settings), - role_(role), - weak_factory_(this) {} +IceTransport::IceTransport(scoped_refptr transport_context) + : transport_context_(transport_context), weak_factory_(this) { + transport_context->Prepare(); +} IceTransport::~IceTransport() { channel_multiplexer_.reset(); DCHECK(channels_.empty()); } -base::Closure IceTransport::GetCanStartClosure() { - return base::Bind(&IceTransport::OnCanStart, - weak_factory_.GetWeakPtr()); -} - void IceTransport::Start(Transport::EventHandler* event_handler, Authenticator* authenticator) { DCHECK(event_handler); @@ -95,24 +88,12 @@ StreamChannelFactory* IceTransport::GetMultiplexedChannelFactory() { return channel_multiplexer_.get(); } -void IceTransport::OnCanStart() { - DCHECK(!can_start_); - - can_start_ = true; - for (ChannelsMap::iterator it = channels_.begin(); it != channels_.end(); - ++it) { - it->second->OnCanStart(); - } -} - void IceTransport::CreateChannel(const std::string& name, const ChannelCreatedCallback& callback) { DCHECK(!channels_[name]); scoped_ptr channel( - new IceTransportChannel(port_allocator_, network_settings_, role_)); - if (can_start_) - channel->OnCanStart(); + new IceTransportChannel(transport_context_)); channel->Connect(name, this, callback); AddPendingRemoteTransportInfo(channel.get()); channels_[name] = channel.release(); @@ -205,5 +186,15 @@ void IceTransport::SendTransportInfo() { pending_transport_info_message_.reset(); } +IceTransportFactory::IceTransportFactory( + scoped_refptr transport_context) + : transport_context_(transport_context) {} + +IceTransportFactory::~IceTransportFactory() {} + +scoped_ptr IceTransportFactory::CreateTransport() { + return make_scoped_ptr(new IceTransport(transport_context_.get())); +} + } // namespace protocol } // namespace remoting diff --git a/remoting/protocol/ice_transport.h b/remoting/protocol/ice_transport.h index 09f7da6..fc72b29 100644 --- a/remoting/protocol/ice_transport.h +++ b/remoting/protocol/ice_transport.h @@ -27,16 +27,10 @@ class IceTransport : public Transport, public IceTransportChannel::Delegate, public DatagramChannelFactory { public: - // |port_allocator| must outlive the session. - IceTransport(cricket::PortAllocator* port_allocator, - const NetworkSettings& network_settings, - TransportRole role); + // |transport_context| must outlive the session. + explicit IceTransport(scoped_refptr transport_context); ~IceTransport() override; - // Returns a closure that must be called before transport channels start - // connecting . - base::Closure GetCanStartClosure(); - // Transport interface. void Start(EventHandler* event_handler, Authenticator* authenticator) override; @@ -47,8 +41,6 @@ class IceTransport : public Transport, private: typedef std::map ChannelsMap; - void OnCanStart(); - // DatagramChannelFactory interface. void CreateChannel(const std::string& name, const ChannelCreatedCallback& callback) override; @@ -76,11 +68,7 @@ class IceTransport : public Transport, // Sends transport-info message with candidates from |pending_candidates_|. void SendTransportInfo(); - cricket::PortAllocator* port_allocator_; - NetworkSettings network_settings_; - TransportRole role_; - - bool can_start_ = false; + scoped_refptr transport_context_; Transport::EventHandler* event_handler_ = nullptr; @@ -102,6 +90,20 @@ class IceTransport : public Transport, DISALLOW_COPY_AND_ASSIGN(IceTransport); }; +class IceTransportFactory : public TransportFactory { + public: + IceTransportFactory(scoped_refptr transport_context); + ~IceTransportFactory() override; + + // TransportFactory interface. + scoped_ptr CreateTransport() override; + + private: + scoped_refptr transport_context_; + + DISALLOW_COPY_AND_ASSIGN(IceTransportFactory); +}; + } // namespace protocol } // namespace remoting diff --git a/remoting/protocol/ice_transport_channel.cc b/remoting/protocol/ice_transport_channel.cc index 7e47bce..1ef4d7d 100644 --- a/remoting/protocol/ice_transport_channel.cc +++ b/remoting/protocol/ice_transport_channel.cc @@ -13,6 +13,7 @@ #include "jingle/glue/utils.h" #include "net/base/net_errors.h" #include "remoting/protocol/channel_socket_adapter.h" +#include "remoting/protocol/transport_context.h" #include "third_party/webrtc/base/network.h" #include "third_party/webrtc/p2p/base/constants.h" #include "third_party/webrtc/p2p/base/p2ptransportchannel.h" @@ -46,16 +47,11 @@ TransportRoute::RouteType CandidateTypeToTransportRouteType( } // namespace -IceTransportChannel::IceTransportChannel(cricket::PortAllocator* port_allocator, - const NetworkSettings& network_settings, - TransportRole role) - : port_allocator_(port_allocator), - network_settings_(network_settings), - role_(role), - delegate_(nullptr), +IceTransportChannel::IceTransportChannel( + scoped_refptr transport_context) + : transport_context_(transport_context), ice_username_fragment_( rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)), - can_start_(false), connect_attempts_left_(kMaxReconnectAttempts), weak_factory_(this) { DCHECK(!ice_username_fragment_.empty()); @@ -66,32 +62,11 @@ IceTransportChannel::~IceTransportChannel() { delegate_->OnTransportDeleted(this); - if (channel_.get()) { - base::ThreadTaskRunnerHandle::Get()->DeleteSoon( - FROM_HERE, channel_.release()); - } -} - -void IceTransportChannel::OnCanStart() { - DCHECK(thread_checker_.CalledOnValidThread()); - - DCHECK(!can_start_); - can_start_ = true; - - // If Connect() has been called then start connection. - if (!callback_.is_null()) - DoStart(); - - // Pass pending ICE credentials and candidates to the channel. - if (!remote_ice_username_fragment_.empty()) { - channel_->SetRemoteIceCredentials(remote_ice_username_fragment_, - remote_ice_password_); - } - - while (!pending_candidates_.empty()) { - channel_->AddRemoteCandidate(pending_candidates_.front()); - pending_candidates_.pop_front(); - } + auto task_runner = base::ThreadTaskRunnerHandle::Get(); + if (channel_) + task_runner->DeleteSoon(FROM_HERE, channel_.release()); + if (port_allocator_) + task_runner->DeleteSoon(FROM_HERE, port_allocator_.release()); } void IceTransportChannel::Connect(const std::string& name, @@ -107,20 +82,24 @@ void IceTransportChannel::Connect(const std::string& name, delegate_ = delegate; callback_ = callback; - if (can_start_) - DoStart(); + transport_context_->CreatePortAllocator( + base::Bind(&IceTransportChannel::OnPortAllocatorCreated, + weak_factory_.GetWeakPtr())); } -void IceTransportChannel::DoStart() { +void IceTransportChannel::OnPortAllocatorCreated( + scoped_ptr port_allocator){ DCHECK(!channel_.get()); + port_allocator_ = port_allocator.Pass(); + // Create P2PTransportChannel, attach signal handlers and connect it. // TODO(sergeyu): Specify correct component ID for the channel. channel_.reset(new cricket::P2PTransportChannel( - std::string(), 0, nullptr, port_allocator_)); + std::string(), 0, nullptr, port_allocator_.get())); std::string ice_password = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH); channel_->SetIceProtocolType(cricket::ICEPROTO_RFC5245); - channel_->SetIceRole((role_ == TransportRole::CLIENT) + channel_->SetIceRole((transport_context_->role() == TransportRole::CLIENT) ? cricket::ICEROLE_CONTROLLING : cricket::ICEROLE_CONTROLLED); delegate_->OnTransportIceCredentials(this, ice_username_fragment_, @@ -134,12 +113,23 @@ void IceTransportChannel::DoStart() { this, &IceTransportChannel::OnReceivingState); channel_->SignalWritableState.connect( this, &IceTransportChannel::OnWritableState); - channel_->set_incoming_only( - !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING)); + channel_->set_incoming_only(!(transport_context_->network_settings().flags & + NetworkSettings::NAT_TRAVERSAL_OUTGOING)); channel_->Connect(); channel_->MaybeStartGathering(); + // Pass pending ICE credentials and candidates to the channel. + if (!remote_ice_username_fragment_.empty()) { + channel_->SetRemoteIceCredentials(remote_ice_username_fragment_, + remote_ice_password_); + } + + while (!pending_candidates_.empty()) { + channel_->AddRemoteCandidate(pending_candidates_.front()); + pending_candidates_.pop_front(); + } + --connect_attempts_left_; // Start reconnection timer. @@ -158,7 +148,7 @@ void IceTransportChannel::NotifyConnected() { } void IceTransportChannel::SetRemoteCredentials(const std::string& ufrag, - const std::string& password) { + const std::string& password) { DCHECK(thread_checker_.CalledOnValidThread()); remote_ice_username_fragment_ = ufrag; @@ -174,7 +164,7 @@ void IceTransportChannel::AddRemoteCandidate( // To enforce the no-relay setting, it's not enough to not produce relay // candidates. It's also necessary to discard remote relay candidates. - bool relay_allowed = (network_settings_.flags & + bool relay_allowed = (transport_context_->network_settings().flags & NetworkSettings::NAT_TRAVERSAL_RELAY) != 0; if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE) return; diff --git a/remoting/protocol/ice_transport_channel.h b/remoting/protocol/ice_transport_channel.h index a0dd6e7..7bde3e5 100644 --- a/remoting/protocol/ice_transport_channel.h +++ b/remoting/protocol/ice_transport_channel.h @@ -26,6 +26,8 @@ class TransportChannelImpl; namespace remoting { namespace protocol { +class TransportContext; + class IceTransportChannel : public sigslot::has_slots<> { public: class Delegate { @@ -59,14 +61,10 @@ class IceTransportChannel : public sigslot::has_slots<> { typedef base::Callback)> ConnectedCallback; - IceTransportChannel(cricket::PortAllocator* port_allocator, - const NetworkSettings& network_settings, - TransportRole role); + explicit IceTransportChannel( + scoped_refptr transport_context); ~IceTransportChannel() override; - // Called by IceTransport when it has fresh Jingle info. - void OnCanStart(); - // Connects the channel and calls the |callback| after that. void Connect(const std::string& name, Delegate* delegate, @@ -87,7 +85,9 @@ class IceTransportChannel : public sigslot::has_slots<> { bool is_connected() const; private: - void DoStart(); + void OnPortAllocatorCreated( + scoped_ptr port_allocator); + void NotifyConnected(); // Signal handlers for cricket::TransportChannel. @@ -107,16 +107,14 @@ class IceTransportChannel : public sigslot::has_slots<> { // Tries to connect by restarting ICE. Called by |reconnect_timer_|. void TryReconnect(); - cricket::PortAllocator* port_allocator_; - NetworkSettings network_settings_; - TransportRole role_; + scoped_refptr transport_context_; std::string name_; - Delegate* delegate_; + Delegate* delegate_ = nullptr; ConnectedCallback callback_; std::string ice_username_fragment_; - bool can_start_; + scoped_ptr port_allocator_; std::string remote_ice_username_fragment_; std::string remote_ice_password_; diff --git a/remoting/protocol/ice_transport_factory.cc b/remoting/protocol/ice_transport_factory.cc deleted file mode 100644 index 19b14cb..0000000 --- a/remoting/protocol/ice_transport_factory.cc +++ /dev/null @@ -1,93 +0,0 @@ -// Copyright 2015 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/ice_transport_factory.h" - -#include "base/single_thread_task_runner.h" -#include "base/thread_task_runner_handle.h" -#include "remoting/protocol/ice_transport.h" -#include "third_party/webrtc/p2p/client/httpportallocator.h" - -namespace remoting { -namespace protocol { - -// Get fresh STUN/Relay configuration every hour. -static const int kJingleInfoUpdatePeriodSeconds = 3600; - -IceTransportFactory::IceTransportFactory( - SignalStrategy* signal_strategy, - scoped_ptr port_allocator, - const NetworkSettings& network_settings, - TransportRole role) - : signal_strategy_(signal_strategy), - port_allocator_(port_allocator.Pass()), - network_settings_(network_settings), - role_(role) {} - -IceTransportFactory::~IceTransportFactory() { - // This method may be called in response to a libjingle signal, so - // libjingle objects must be deleted asynchronously. - scoped_refptr task_runner = - base::ThreadTaskRunnerHandle::Get(); - task_runner->DeleteSoon(FROM_HERE, port_allocator_.release()); -} - -scoped_ptr IceTransportFactory::CreateTransport() { - scoped_ptr result( - new IceTransport(port_allocator_.get(), network_settings_, role_)); - - EnsureFreshJingleInfo(); - - // If there is a pending |jingle_info_request_| delay starting the new - // transport until the request is finished. - if (jingle_info_request_) { - on_jingle_info_callbacks_.push_back(result->GetCanStartClosure()); - } else { - result->GetCanStartClosure().Run(); - } - - return result.Pass(); -} - -void IceTransportFactory::EnsureFreshJingleInfo() { - uint32 stun_or_relay_flags = NetworkSettings::NAT_TRAVERSAL_STUN | - NetworkSettings::NAT_TRAVERSAL_RELAY; - if (!(network_settings_.flags & stun_or_relay_flags) || - jingle_info_request_) { - return; - } - - if (last_jingle_info_update_time_.is_null() || - base::TimeTicks::Now() - last_jingle_info_update_time_ > - base::TimeDelta::FromSeconds(kJingleInfoUpdatePeriodSeconds)) { - jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_)); - jingle_info_request_->Send(base::Bind( - &IceTransportFactory::OnJingleInfo, base::Unretained(this))); - } -} - -void IceTransportFactory::OnJingleInfo( - const std::string& relay_token, - const std::vector& relay_hosts, - const std::vector& stun_hosts) { - if (!relay_token.empty() && !relay_hosts.empty()) { - port_allocator_->SetRelayHosts(relay_hosts); - port_allocator_->SetRelayToken(relay_token); - } - if (!stun_hosts.empty()) { - port_allocator_->SetStunHosts(stun_hosts); - } - - jingle_info_request_.reset(); - if ((!relay_token.empty() && !relay_hosts.empty()) || !stun_hosts.empty()) - last_jingle_info_update_time_ = base::TimeTicks::Now(); - - while (!on_jingle_info_callbacks_.empty()) { - on_jingle_info_callbacks_.begin()->Run(); - on_jingle_info_callbacks_.pop_front(); - } -} - -} // namespace protocol -} // namespace remoting diff --git a/remoting/protocol/ice_transport_factory.h b/remoting/protocol/ice_transport_factory.h deleted file mode 100644 index deaf72e..0000000 --- a/remoting/protocol/ice_transport_factory.h +++ /dev/null @@ -1,61 +0,0 @@ -// Copyright 2015 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. - -#ifndef REMOTING_PROTOCOL_ICE_TRANSPORT_FACTORY_H_ -#define REMOTING_PROTOCOL_ICE_TRANSPORT_FACTORY_H_ - -#include - -#include "base/macros.h" -#include "remoting/protocol/network_settings.h" -#include "remoting/protocol/transport.h" -#include "remoting/signaling/jingle_info_request.h" - -namespace cricket { -class HttpPortAllocatorBase; -} // namespace cricket - -namespace remoting { - -class SignalStrategy; - -namespace protocol { - -class IceTransportFactory : public TransportFactory { - public: - IceTransportFactory( - SignalStrategy* signal_strategy, - scoped_ptr port_allocator, - const NetworkSettings& network_settings, - TransportRole role); - ~IceTransportFactory() override; - - // TransportFactory interface. - scoped_ptr CreateTransport() override; - - private: - void EnsureFreshJingleInfo(); - void OnJingleInfo(const std::string& relay_token, - const std::vector& relay_hosts, - const std::vector& stun_hosts); - - SignalStrategy* signal_strategy_; - scoped_ptr port_allocator_; - NetworkSettings network_settings_; - TransportRole role_; - - base::TimeTicks last_jingle_info_update_time_; - scoped_ptr jingle_info_request_; - - // When there is an active |jingle_info_request_| stores list of callbacks to - // be called once the |jingle_info_request_| is finished. - std::list on_jingle_info_callbacks_; - - DISALLOW_COPY_AND_ASSIGN(IceTransportFactory); -}; - -} // namespace protocol -} // namespace remoting - -#endif // REMOTING_PROTOCOL_ICE_TRANSPORT_FACTORY_H_ diff --git a/remoting/protocol/ice_transport_unittest.cc b/remoting/protocol/ice_transport_unittest.cc index 110a6d7..1f881a6 100644 --- a/remoting/protocol/ice_transport_unittest.cc +++ b/remoting/protocol/ice_transport_unittest.cc @@ -17,6 +17,7 @@ #include "remoting/protocol/fake_authenticator.h" #include "remoting/protocol/p2p_stream_socket.h" #include "remoting/protocol/stream_channel_factory.h" +#include "remoting/protocol/transport_context.h" #include "remoting/signaling/fake_signal_strategy.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" @@ -128,20 +129,19 @@ class IceTransportTest : public testing::Test { } void InitializeConnection() { - port_allocator_ = ChromiumPortAllocator::Create(nullptr, network_settings_); - - host_transport_.reset(new IceTransport( - port_allocator_.get(), network_settings_, TransportRole::SERVER)); - host_transport_->GetCanStartClosure().Run(); - + host_transport_.reset(new IceTransport(new TransportContext( + signal_strategy_.get(), + make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)), + network_settings_, TransportRole::SERVER))); if (!host_authenticator_) { host_authenticator_.reset(new FakeAuthenticator( FakeAuthenticator::HOST, 0, FakeAuthenticator::ACCEPT, true)); } - client_transport_.reset(new IceTransport( - port_allocator_.get(), network_settings_, TransportRole::CLIENT)); - client_transport_->GetCanStartClosure().Run(); + client_transport_.reset(new IceTransport(new TransportContext( + signal_strategy_.get(), + make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)), + network_settings_, TransportRole::CLIENT))); if (!client_authenticator_) { client_authenticator_.reset(new FakeAuthenticator( FakeAuthenticator::CLIENT, 0, FakeAuthenticator::ACCEPT, true)); @@ -208,14 +208,10 @@ class IceTransportTest : public testing::Test { base::TimeDelta transport_info_delay_; - scoped_ptr port_allocator_; - - // scoped_ptr host_transport_factory_; scoped_ptr host_transport_; TestTransportEventHandler host_event_handler_; scoped_ptr host_authenticator_; - // scoped_ptr client_transport_factory_; scoped_ptr client_transport_; TestTransportEventHandler client_event_handler_; scoped_ptr client_authenticator_; diff --git a/remoting/protocol/jingle_session_unittest.cc b/remoting/protocol/jingle_session_unittest.cc index c1338951..03cb533 100644 --- a/remoting/protocol/jingle_session_unittest.cc +++ b/remoting/protocol/jingle_session_unittest.cc @@ -19,9 +19,10 @@ #include "remoting/protocol/chromium_port_allocator.h" #include "remoting/protocol/connection_tester.h" #include "remoting/protocol/fake_authenticator.h" -#include "remoting/protocol/ice_transport_factory.h" +#include "remoting/protocol/ice_transport.h" #include "remoting/protocol/jingle_session_manager.h" #include "remoting/protocol/network_settings.h" +#include "remoting/protocol/transport_context.h" #include "remoting/signaling/fake_signal_strategy.h" #include "testing/gmock/include/gmock/gmock.h" #include "testing/gtest/include/gtest/gtest.h" @@ -102,11 +103,10 @@ class JingleSessionTest : public testing::Test { FakeSignalStrategy::Connect(host_signal_strategy_.get(), client_signal_strategy_.get()); - scoped_ptr host_transport(new IceTransportFactory( - nullptr, - ChromiumPortAllocator::Create(nullptr, network_settings_).Pass(), - network_settings_, TransportRole::SERVER)); - host_server_.reset(new JingleSessionManager(host_transport.Pass())); + host_server_.reset(new JingleSessionManager( + make_scoped_ptr(new IceTransportFactory(new TransportContext( + nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)), + network_settings_, TransportRole::SERVER))))); host_server_->Init(host_signal_strategy_.get(), &host_server_listener_); scoped_ptr factory( @@ -114,12 +114,10 @@ class JingleSessionTest : public testing::Test { messages_till_start, auth_action, true)); host_server_->set_authenticator_factory(factory.Pass()); - scoped_ptr client_transport(new IceTransportFactory( - nullptr, - ChromiumPortAllocator::Create(nullptr, network_settings_).Pass(), - network_settings_, TransportRole::CLIENT)); - client_server_.reset( - new JingleSessionManager(client_transport.Pass())); + client_server_.reset(new JingleSessionManager( + make_scoped_ptr(new IceTransportFactory(new TransportContext( + nullptr, make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)), + network_settings_, TransportRole::CLIENT))))); client_server_->Init(client_signal_strategy_.get(), &client_server_listener_); } diff --git a/remoting/protocol/port_allocator_factory.h b/remoting/protocol/port_allocator_factory.h index 741ccca..b08df71 100644 --- a/remoting/protocol/port_allocator_factory.h +++ b/remoting/protocol/port_allocator_factory.h @@ -5,7 +5,11 @@ #ifndef REMOTING_PROTOCOL_PORT_ALLOCATOR_FACTORY_H_ #define REMOTING_PROTOCOL_PORT_ALLOCATOR_FACTORY_H_ -#include "third_party/webrtc/p2p/base/portallocator.h" +#include "base/memory/scoped_ptr.h" + +namespace cricket { +class HttpPortAllocatorBase; +} // namespace cricket namespace remoting { namespace protocol { @@ -14,7 +18,7 @@ namespace protocol { // for ICE negotiation. class PortAllocatorFactory { public: - virtual cricket::PortAllocator* CreatePortAllocator() = 0; + virtual scoped_ptr CreatePortAllocator() = 0; virtual ~PortAllocatorFactory() {} }; diff --git a/remoting/protocol/transport_context.cc b/remoting/protocol/transport_context.cc new file mode 100644 index 0000000..251a028 --- /dev/null +++ b/remoting/protocol/transport_context.cc @@ -0,0 +1,122 @@ +// Copyright 2015 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/transport_context.h" + +#include "base/bind.h" +#include "base/location.h" +#include "base/single_thread_task_runner.h" +#include "base/thread_task_runner_handle.h" +#include "remoting/protocol/port_allocator_factory.h" +#include "third_party/webrtc/p2p/client/httpportallocator.h" + +namespace remoting { +namespace protocol { + +// Get fresh STUN/Relay configuration every hour. +static const int kJingleInfoUpdatePeriodSeconds = 3600; + +TransportContext::TransportContext( + SignalStrategy* signal_strategy, + scoped_ptr port_allocator_factory, + const NetworkSettings& network_settings, + TransportRole role) + : signal_strategy_(signal_strategy), + port_allocator_factory_(port_allocator_factory.Pass()), + network_settings_(network_settings), + role_(role) {} + +TransportContext::~TransportContext() {} + +void TransportContext::Prepare() { + EnsureFreshJingleInfo(); +} + +void TransportContext::CreatePortAllocator( + const CreatePortAllocatorCallback& callback) { + EnsureFreshJingleInfo(); + + // If there is a pending |jingle_info_request_| delay starting the new + // transport until the request is finished. + if (jingle_info_request_) { + pending_port_allocator_requests_.push_back(callback); + } else { + callback.Run(CreatePortAllocatorInternal()); + } +} + +void TransportContext::EnsureFreshJingleInfo() { + // Check if request is already pending. + if (jingle_info_request_) + return; + + // Don't need to make jingleinfo request if both STUN and Relay are disabled. + if ((network_settings_.flags & (NetworkSettings::NAT_TRAVERSAL_STUN | + NetworkSettings::NAT_TRAVERSAL_RELAY)) == 0) { + return; + } + + if (last_jingle_info_update_time_.is_null() || + base::TimeTicks::Now() - last_jingle_info_update_time_ > + base::TimeDelta::FromSeconds(kJingleInfoUpdatePeriodSeconds)) { + jingle_info_request_.reset(new JingleInfoRequest(signal_strategy_)); + jingle_info_request_->Send(base::Bind( + &TransportContext::OnJingleInfo, base::Unretained(this))); + } +} + +void TransportContext::OnJingleInfo( + const std::string& relay_token, + const std::vector& relay_hosts, + const std::vector& stun_hosts) { + relay_token_ = relay_token; + relay_hosts_ = relay_hosts; + stun_hosts_ = stun_hosts; + + jingle_info_request_.reset(); + if ((!relay_token.empty() && !relay_hosts.empty()) || !stun_hosts.empty()) + last_jingle_info_update_time_ = base::TimeTicks::Now(); + + while (!pending_port_allocator_requests_.empty()) { + pending_port_allocator_requests_.begin()->Run( + CreatePortAllocatorInternal()); + pending_port_allocator_requests_.pop_front(); + } +} + +scoped_ptr +TransportContext::CreatePortAllocatorInternal() { + scoped_ptr result = + port_allocator_factory_->CreatePortAllocator(); + + if (!relay_token_.empty() && !relay_hosts_.empty()) { + result->SetRelayHosts(relay_hosts_); + result->SetRelayToken(relay_token_); + } + if (!stun_hosts_.empty()) + result->SetStunHosts(stun_hosts_); + + // We always use PseudoTcp to provide a reliable channel. It provides poor + // performance when combined with TCP-based transport, so we have to disable + // TCP ports. ENABLE_SHARED_UFRAG flag is specified so that the same username + // fragment is shared between all candidates. + int flags = cricket::PORTALLOCATOR_DISABLE_TCP | + cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | + cricket::PORTALLOCATOR_ENABLE_IPV6; + + if (!(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_STUN)) + flags |= cricket::PORTALLOCATOR_DISABLE_STUN; + + if (!(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_RELAY)) + flags |= cricket::PORTALLOCATOR_DISABLE_RELAY; + + result->set_flags(flags); + result->SetPortRange(network_settings_.port_range.min_port, + network_settings_.port_range.max_port); + + return result.Pass(); +} + +} // namespace protocol +} // namespace remoting diff --git a/remoting/protocol/transport_context.h b/remoting/protocol/transport_context.h new file mode 100644 index 0000000..faac2d2 --- /dev/null +++ b/remoting/protocol/transport_context.h @@ -0,0 +1,92 @@ +// Copyright 2015 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. + +#ifndef REMOTING_PROTOCOL_TRANSPORT_CONTEXT_H_ +#define REMOTING_PROTOCOL_TRANSPORT_CONTEXT_H_ + +#include +#include +#include + +#include "base/macros.h" +#include "base/memory/ref_counted.h" +#include "base/memory/scoped_ptr.h" +#include "remoting/protocol/network_settings.h" +#include "remoting/protocol/transport.h" +#include "remoting/signaling/jingle_info_request.h" + +namespace cricket { +class PortAllocator; +} // namespace cricket + +namespace remoting { + +class SignalStrategy; + +namespace protocol { + +class PortAllocatorFactory; + +// TransportContext is responsible for storing all parameters required for +// P2P transport initialization. It's also responsible for making JingleInfo +// request and creation of PortAllocators configured according to the JingleInfo +// result. +class TransportContext : public base::RefCountedThreadSafe { + public: + typedef base::Callback + port_allocator)> CreatePortAllocatorCallback; + + TransportContext( + SignalStrategy* signal_strategy, + scoped_ptr port_allocator_factory, + const NetworkSettings& network_settings, + TransportRole role); + + // Prepares to create new PortAllocator instances. It may be called while + // connection is being negotiated to minimize the chance that the following + // CreatePortAllocator() will be blocking. + void Prepare(); + + // Creates new PortAllocator making sure that it has correct STUN and TURN + // information. + void CreatePortAllocator(const CreatePortAllocatorCallback& callback); + + const NetworkSettings& network_settings() { return network_settings_; } + TransportRole role() { return role_; } + + private: + friend class base::RefCountedThreadSafe; + + ~TransportContext(); + + void EnsureFreshJingleInfo(); + void OnJingleInfo(const std::string& relay_token, + const std::vector& relay_hosts, + const std::vector& stun_hosts); + + scoped_ptr CreatePortAllocatorInternal(); + + SignalStrategy* signal_strategy_; + scoped_ptr port_allocator_factory_; + NetworkSettings network_settings_; + TransportRole role_; + + base::TimeTicks last_jingle_info_update_time_; + scoped_ptr jingle_info_request_; + + std::string relay_token_; + std::vector relay_hosts_; + std::vector stun_hosts_; + + // When there is an active |jingle_info_request_| stores list of callbacks to + // be called once the |jingle_info_request_| is finished. + std::list pending_port_allocator_requests_; + + DISALLOW_COPY_AND_ASSIGN(TransportContext); +}; + +} // namespace protocol +} // namespace remoting + +#endif // REMOTING_PROTOCOL_TRANSPORT_CONTEXT_H_ diff --git a/remoting/protocol/webrtc_transport.cc b/remoting/protocol/webrtc_transport.cc index 2c82aab..e4fd5c8f 100644 --- a/remoting/protocol/webrtc_transport.cc +++ b/remoting/protocol/webrtc_transport.cc @@ -10,6 +10,7 @@ #include "base/task_runner_util.h" #include "base/thread_task_runner_handle.h" #include "jingle/glue/thread_wrapper.h" +#include "remoting/protocol/transport_context.h" #include "third_party/libjingle/source/talk/app/webrtc/test/fakeconstraints.h" #include "third_party/webrtc/libjingle/xmllite/xmlelement.h" #include "third_party/webrtc/modules/audio_device/include/fake_audio_device.h" @@ -99,11 +100,10 @@ class SetSessionDescriptionObserver } // namespace -WebrtcTransport::WebrtcTransport(rtc::Thread* worker_thread, - PortAllocatorFactory* port_allocator_factory, - TransportRole role) - : port_allocator_factory_(port_allocator_factory), - role_(role), +WebrtcTransport::WebrtcTransport( + rtc::Thread* worker_thread, + scoped_refptr transport_context) + : transport_context_(transport_context), worker_thread_(worker_thread), weak_factory_(this) {} @@ -114,8 +114,14 @@ void WebrtcTransport::Start(EventHandler* event_handler, DCHECK(thread_checker_.CalledOnValidThread()); event_handler_ = event_handler; - // TODO(sergeyu): Use the |authenticator| to authenticate PeerConnection. + + transport_context_->CreatePortAllocator(base::Bind( + &WebrtcTransport::OnPortAllocatorCreated, weak_factory_.GetWeakPtr())); +} + +void WebrtcTransport::OnPortAllocatorCreated( + scoped_ptr port_allocator) { jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop(); // TODO(sergeyu): Investigate if it's possible to avoid Send(). @@ -136,16 +142,15 @@ void WebrtcTransport::Start(EventHandler* event_handler, constraints.AddMandatory(webrtc::MediaConstraintsInterface::kEnableDtlsSrtp, webrtc::MediaConstraintsInterface::kValueTrue); - rtc::scoped_ptr port_allocator( - port_allocator_factory_->CreatePortAllocator()); - peer_connection_ = peer_connection_factory_->CreatePeerConnection( - rtc_config, &constraints, std::move(port_allocator), nullptr, this); + rtc_config, &constraints, + rtc::scoped_ptr(port_allocator.release()), + nullptr, this); - data_stream_adapter_.Initialize(peer_connection_, - role_ == TransportRole::SERVER); + data_stream_adapter_.Initialize( + peer_connection_, transport_context_->role() == TransportRole::SERVER); - if (role_ == TransportRole::SERVER) + if (transport_context_->role() == TransportRole::SERVER) RequestNegotiation(); } @@ -162,7 +167,7 @@ bool WebrtcTransport::ProcessTransportInfo(XmlElement* transport_info) { QName(kTransportNamespace, "session-description")); if (session_description) { webrtc::PeerConnectionInterface::SignalingState expected_state = - role_ == TransportRole::CLIENT + transport_context_->role() == TransportRole::CLIENT ? webrtc::PeerConnectionInterface::kStable : webrtc::PeerConnectionInterface::kHaveLocalOffer; if (peer_connection_->signaling_state() != expected_state) { @@ -365,7 +370,7 @@ void WebrtcTransport::OnDataChannel( void WebrtcTransport::OnRenegotiationNeeded() { DCHECK(thread_checker_.CalledOnValidThread()); - if (role_ == TransportRole::SERVER) { + if (transport_context_->role() == TransportRole::SERVER) { RequestNegotiation(); } else { // TODO(sergeyu): Is it necessary to support renegotiation initiated by the @@ -375,7 +380,7 @@ void WebrtcTransport::OnRenegotiationNeeded() { } void WebrtcTransport::RequestNegotiation() { - DCHECK(role_ == TransportRole::SERVER); + DCHECK(transport_context_->role() == TransportRole::SERVER); if (!negotiation_pending_) { negotiation_pending_ = true; @@ -440,7 +445,7 @@ void WebrtcTransport::EnsurePendingTransportInfoMessage() { } void WebrtcTransport::SendOffer() { - DCHECK(role_ == TransportRole::SERVER); + DCHECK(transport_context_->role() == TransportRole::SERVER); DCHECK(negotiation_pending_); negotiation_pending_ = false; @@ -488,19 +493,15 @@ void WebrtcTransport::AddPendingCandidatesIfPossible() { WebrtcTransportFactory::WebrtcTransportFactory( rtc::Thread* worker_thread, - SignalStrategy* signal_strategy, - scoped_ptr port_allocator_factory, - TransportRole role) + scoped_refptr transport_context) : worker_thread_(worker_thread), - signal_strategy_(signal_strategy), - port_allocator_factory_(std::move(port_allocator_factory)), - role_(role) {} + transport_context_(transport_context) {} WebrtcTransportFactory::~WebrtcTransportFactory() {} scoped_ptr WebrtcTransportFactory::CreateTransport() { - return make_scoped_ptr(new WebrtcTransport( - worker_thread_, port_allocator_factory_.get(), role_)); + return make_scoped_ptr( + new WebrtcTransport(worker_thread_, transport_context_.get())); } } // namespace protocol diff --git a/remoting/protocol/webrtc_transport.h b/remoting/protocol/webrtc_transport.h index 6fc79d7..827d2ef 100644 --- a/remoting/protocol/webrtc_transport.h +++ b/remoting/protocol/webrtc_transport.h @@ -25,12 +25,13 @@ class FakeAudioDeviceModule; namespace remoting { namespace protocol { +class TransportContext; + class WebrtcTransport : public Transport, public webrtc::PeerConnectionObserver { public: WebrtcTransport(rtc::Thread* worker_thread, - PortAllocatorFactory* port_allocator_factory, - TransportRole role); + scoped_refptr transport_context); ~WebrtcTransport() override; webrtc::PeerConnectionInterface* peer_connection() { @@ -49,6 +50,9 @@ class WebrtcTransport : public Transport, WebrtcTransport* AsWebrtcTransport() override; private: + void OnPortAllocatorCreated( + scoped_ptr port_allocator); + void OnLocalSessionDescriptionCreated( scoped_ptr description, const std::string& error); @@ -80,8 +84,7 @@ class WebrtcTransport : public Transport, base::ThreadChecker thread_checker_; - PortAllocatorFactory* port_allocator_factory_; - TransportRole role_; + scoped_refptr transport_context_; EventHandler* event_handler_ = nullptr; rtc::Thread* worker_thread_; @@ -110,11 +113,8 @@ class WebrtcTransport : public Transport, class WebrtcTransportFactory : public TransportFactory { public: - WebrtcTransportFactory( - rtc::Thread* worker_thread, - SignalStrategy* signal_strategy, - scoped_ptr port_allocator_factory, - TransportRole role); + WebrtcTransportFactory(rtc::Thread* worker_thread, + scoped_refptr transport_context); ~WebrtcTransportFactory() override; // TransportFactory interface. @@ -122,9 +122,7 @@ class WebrtcTransportFactory : public TransportFactory { private: rtc::Thread* worker_thread_; - SignalStrategy* signal_strategy_; - scoped_ptr port_allocator_factory_; - TransportRole role_; + scoped_refptr transport_context_; DISALLOW_COPY_AND_ASSIGN(WebrtcTransportFactory); }; diff --git a/remoting/protocol/webrtc_transport_unittest.cc b/remoting/protocol/webrtc_transport_unittest.cc index 1797a7e..82fb6d3 100644 --- a/remoting/protocol/webrtc_transport_unittest.cc +++ b/remoting/protocol/webrtc_transport_unittest.cc @@ -9,11 +9,12 @@ #include "jingle/glue/thread_wrapper.h" #include "net/base/io_buffer.h" #include "net/url_request/url_request_context_getter.h" -#include "remoting/protocol/chromium_port_allocator_factory.h" +#include "remoting/protocol/chromium_port_allocator.h" #include "remoting/protocol/connection_tester.h" #include "remoting/protocol/fake_authenticator.h" #include "remoting/protocol/network_settings.h" #include "remoting/protocol/p2p_stream_socket.h" +#include "remoting/protocol/transport_context.h" #include "remoting/signaling/fake_signal_strategy.h" #include "testing/gtest/include/gtest/gtest.h" #include "third_party/webrtc/libjingle/xmllite/xmlelement.h" @@ -90,17 +91,21 @@ class WebrtcTransportTest : public testing::Test { signal_strategy_.reset(new FakeSignalStrategy(kTestJid)); host_transport_factory_.reset(new WebrtcTransportFactory( - jingle_glue::JingleThreadWrapper::current(), signal_strategy_.get(), - ChromiumPortAllocatorFactory::Create(network_settings_, nullptr), - TransportRole::SERVER)); + jingle_glue::JingleThreadWrapper::current(), + new TransportContext( + signal_strategy_.get(), + make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)), + network_settings_, TransportRole::SERVER))); host_transport_ = host_transport_factory_->CreateTransport(); host_authenticator_.reset(new FakeAuthenticator( FakeAuthenticator::HOST, 0, FakeAuthenticator::ACCEPT, false)); client_transport_factory_.reset(new WebrtcTransportFactory( - jingle_glue::JingleThreadWrapper::current(), signal_strategy_.get(), - ChromiumPortAllocatorFactory::Create(network_settings_, nullptr), - TransportRole::CLIENT)); + jingle_glue::JingleThreadWrapper::current(), + new TransportContext( + signal_strategy_.get(), + make_scoped_ptr(new ChromiumPortAllocatorFactory(nullptr)), + network_settings_, TransportRole::CLIENT))); client_transport_ = client_transport_factory_->CreateTransport(); host_authenticator_.reset(new FakeAuthenticator( FakeAuthenticator::CLIENT, 0, FakeAuthenticator::ACCEPT, false)); diff --git a/remoting/remoting_host_srcs.gypi b/remoting/remoting_host_srcs.gypi index 6df087a..766d556 100644 --- a/remoting/remoting_host_srcs.gypi +++ b/remoting/remoting_host_srcs.gypi @@ -218,8 +218,6 @@ 'host/screen_resolution.h', 'host/server_log_entry_host.cc', 'host/server_log_entry_host.h', - 'host/session_manager_factory.cc', - 'host/session_manager_factory.h', 'host/shaped_desktop_capturer.cc', 'host/shaped_desktop_capturer.h', 'host/shutdown_watchdog.cc', diff --git a/remoting/remoting_srcs.gypi b/remoting/remoting_srcs.gypi index b5e2153..aac6cc7 100644 --- a/remoting/remoting_srcs.gypi +++ b/remoting/remoting_srcs.gypi @@ -118,8 +118,6 @@ 'protocol/host_video_dispatcher.h', 'protocol/ice_transport_channel.cc', 'protocol/ice_transport_channel.h', - 'protocol/ice_transport_factory.cc', - 'protocol/ice_transport_factory.h', 'protocol/ice_transport.cc', 'protocol/ice_transport.h', 'protocol/input_event_tracker.cc', @@ -193,6 +191,8 @@ 'protocol/token_validator.h', 'protocol/transport.cc', 'protocol/transport.h', + 'protocol/transport_context.cc', + 'protocol/transport_context.h', 'protocol/v2_authenticator.cc', 'protocol/v2_authenticator.h', 'protocol/video_stub.h', @@ -204,8 +204,6 @@ 'protocol/capture_scheduler.h', 'protocol/chromium_port_allocator.cc', 'protocol/chromium_port_allocator.h', - 'protocol/chromium_port_allocator_factory.cc', - 'protocol/chromium_port_allocator_factory.h', 'protocol/chromium_socket_factory.cc', 'protocol/chromium_socket_factory.h', 'protocol/ice_connection_to_client.cc', diff --git a/remoting/test/fake_port_allocator.cc b/remoting/test/fake_port_allocator.cc index d63243f..972ded5 100644 --- a/remoting/test/fake_port_allocator.cc +++ b/remoting/test/fake_port_allocator.cc @@ -7,6 +7,7 @@ #include "remoting/test/fake_network_dispatcher.h" #include "remoting/test/fake_network_manager.h" #include "remoting/test/fake_socket_factory.h" +#include "third_party/webrtc/p2p/client/basicportallocator.h" namespace remoting { @@ -82,35 +83,10 @@ void FakePortAllocatorSession::SendSessionRequest( } // namespace -// static -scoped_ptr FakePortAllocator::Create( - scoped_refptr fake_network_dispatcher) { - scoped_ptr socket_factory( - new FakePacketSocketFactory(fake_network_dispatcher.get())); - scoped_ptr network_manager( - new FakeNetworkManager(socket_factory->GetAddress())); - - return make_scoped_ptr( - new FakePortAllocator(network_manager.Pass(), socket_factory.Pass())); -} - -FakePortAllocator::FakePortAllocator( - scoped_ptr network_manager, - scoped_ptr socket_factory) - : HttpPortAllocatorBase(network_manager.get(), - socket_factory.get(), - std::string()), - network_manager_(network_manager.Pass()), - socket_factory_(socket_factory.Pass()) { - set_flags(cricket::PORTALLOCATOR_DISABLE_TCP | - cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG | - cricket::PORTALLOCATOR_ENABLE_IPV6 | - cricket::PORTALLOCATOR_DISABLE_STUN | - cricket::PORTALLOCATOR_DISABLE_RELAY); -} - -FakePortAllocator::~FakePortAllocator() { -} +FakePortAllocator::FakePortAllocator(rtc::NetworkManager* network_manager, + FakePacketSocketFactory* socket_factory) + : HttpPortAllocatorBase(network_manager, socket_factory, std::string()) {} +FakePortAllocator::~FakePortAllocator() {} cricket::PortAllocatorSession* FakePortAllocator::CreateSessionInternal( const std::string& content_name, @@ -122,4 +98,19 @@ cricket::PortAllocatorSession* FakePortAllocator::CreateSessionInternal( stun_hosts(), relay_hosts(), relay_token()); } +FakePortAllocatorFactory::FakePortAllocatorFactory( + scoped_refptr fake_network_dispatcher) { + socket_factory_.reset( + new FakePacketSocketFactory(fake_network_dispatcher.get())); + network_manager_.reset(new FakeNetworkManager(socket_factory_->GetAddress())); +} + +FakePortAllocatorFactory::~FakePortAllocatorFactory() {} + +scoped_ptr +FakePortAllocatorFactory::CreatePortAllocator() { + return make_scoped_ptr( + new FakePortAllocator(network_manager_.get(), socket_factory_.get())); +} + } // namespace remoting diff --git a/remoting/test/fake_port_allocator.h b/remoting/test/fake_port_allocator.h index af6ec3f8..d848dfd 100644 --- a/remoting/test/fake_port_allocator.h +++ b/remoting/test/fake_port_allocator.h @@ -9,8 +9,13 @@ #include "base/memory/ref_counted.h" #include "base/memory/scoped_ptr.h" +#include "remoting/protocol/port_allocator_factory.h" #include "third_party/webrtc/p2p/client/httpportallocator.h" +namespace rtc { +class NetworkManager; +} // namespace rtc + namespace remoting { class FakeNetworkDispatcher; @@ -18,13 +23,10 @@ class FakePacketSocketFactory; class FakePortAllocator : public cricket::HttpPortAllocatorBase { public: - static scoped_ptr Create( - scoped_refptr fake_network_dispatcher); - + FakePortAllocator(rtc::NetworkManager* network_manager, + FakePacketSocketFactory* socket_factory); ~FakePortAllocator() override; - FakePacketSocketFactory* socket_factory() { return socket_factory_.get(); } - // cricket::BasicPortAllocator overrides. cricket::PortAllocatorSession* CreateSessionInternal( const std::string& content_name, @@ -33,13 +35,25 @@ class FakePortAllocator : public cricket::HttpPortAllocatorBase { const std::string& ice_password) override; private: - FakePortAllocator(scoped_ptr network_manager, - scoped_ptr socket_factory); + DISALLOW_COPY_AND_ASSIGN(FakePortAllocator); +}; +class FakePortAllocatorFactory : public protocol::PortAllocatorFactory { + public: + FakePortAllocatorFactory( + scoped_refptr fake_network_dispatcher); + ~FakePortAllocatorFactory() override; + + FakePacketSocketFactory* socket_factory() { return socket_factory_.get(); } + + // PortAllocatorFactory interface. + scoped_ptr CreatePortAllocator() override; + + private: scoped_ptr network_manager_; scoped_ptr socket_factory_; - DISALLOW_COPY_AND_ASSIGN(FakePortAllocator); + DISALLOW_COPY_AND_ASSIGN(FakePortAllocatorFactory); }; } // namespace remoting diff --git a/remoting/test/protocol_perftest.cc b/remoting/test/protocol_perftest.cc index 61294da..92cc8fe 100644 --- a/remoting/test/protocol_perftest.cc +++ b/remoting/test/protocol_perftest.cc @@ -22,11 +22,12 @@ #include "remoting/host/chromoting_host.h" #include "remoting/host/chromoting_host_context.h" #include "remoting/host/fake_desktop_environment.h" -#include "remoting/protocol/ice_transport_factory.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/negotiating_client_authenticator.h" #include "remoting/protocol/session_config.h" +#include "remoting/protocol/transport_context.h" #include "remoting/protocol/video_frame_pump.h" #include "remoting/signaling/fake_signal_strategy.h" #include "remoting/test/fake_network_dispatcher.h" @@ -224,21 +225,22 @@ class ProtocolPerfTest protocol::NetworkSettings network_settings( protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING); - scoped_ptr port_allocator( - FakePortAllocator::Create(fake_network_dispatcher_)); - port_allocator->socket_factory()->SetBandwidth(GetParam().bandwidth, - GetParam().max_buffers); - port_allocator->socket_factory()->SetLatency(GetParam().latency_average, - GetParam().latency_stddev); - port_allocator->socket_factory()->set_out_of_order_rate( + scoped_ptr port_allocator_factory( + new FakePortAllocatorFactory(fake_network_dispatcher_)); + port_allocator_factory->socket_factory()->SetBandwidth( + GetParam().bandwidth, GetParam().max_buffers); + port_allocator_factory->socket_factory()->SetLatency( + GetParam().latency_average, GetParam().latency_stddev); + port_allocator_factory->socket_factory()->set_out_of_order_rate( GetParam().out_of_order_rate); - scoped_ptr host_transport_factory( - new protocol::IceTransportFactory( - host_signaling_.get(), port_allocator.Pass(), network_settings, - protocol::TransportRole::SERVER)); + scoped_refptr transport_context( + new protocol::TransportContext( + host_signaling_.get(), port_allocator_factory.Pass(), + network_settings, protocol::TransportRole::SERVER)); scoped_ptr session_manager( - new protocol::JingleSessionManager(host_transport_factory.Pass())); + new protocol::JingleSessionManager(make_scoped_ptr( + new protocol::IceTransportFactory(transport_context)))); session_manager->set_protocol_config(protocol_config_->Clone()); // Encoder runs on a separate thread, main thread is used for everything @@ -267,7 +269,6 @@ class ProtocolPerfTest scoped_refptr key_pair = RsaKeyPair::FromString(key_base64); ASSERT_TRUE(key_pair.get()); - protocol::SharedSecretHash host_secret; host_secret.hash_function = protocol::AuthenticationMethod::NONE; host_secret.value = "123456"; @@ -294,18 +295,18 @@ class ProtocolPerfTest client_context_.reset( new ClientContext(base::ThreadTaskRunnerHandle::Get())); - scoped_ptr port_allocator( - FakePortAllocator::Create(fake_network_dispatcher_)); - port_allocator->socket_factory()->SetBandwidth(GetParam().bandwidth, - GetParam().max_buffers); - port_allocator->socket_factory()->SetLatency(GetParam().latency_average, - GetParam().latency_stddev); - port_allocator->socket_factory()->set_out_of_order_rate( + scoped_ptr port_allocator_factory( + new FakePortAllocatorFactory(fake_network_dispatcher_)); + port_allocator_factory->socket_factory()->SetBandwidth( + GetParam().bandwidth, GetParam().max_buffers); + port_allocator_factory->socket_factory()->SetLatency( + GetParam().latency_average, GetParam().latency_stddev); + port_allocator_factory->socket_factory()->set_out_of_order_rate( GetParam().out_of_order_rate); - scoped_ptr client_transport_factory( - new protocol::IceTransportFactory( - client_signaling_.get(), port_allocator.Pass(), network_settings, - protocol::TransportRole::CLIENT)); + scoped_refptr transport_context( + new protocol::TransportContext( + host_signaling_.get(), port_allocator_factory.Pass(), + network_settings, protocol::TransportRole::SERVER)); std::vector auth_methods; auth_methods.push_back(protocol::AuthenticationMethod::Spake2( @@ -322,7 +323,7 @@ class ProtocolPerfTest new ChromotingClient(client_context_.get(), this, this, nullptr)); client_->set_protocol_config(protocol_config_->Clone()); client_->Start(client_signaling_.get(), client_authenticator.Pass(), - client_transport_factory.Pass(), kHostJid, std::string()); + transport_context, kHostJid, std::string()); } void FetchPin( diff --git a/remoting/test/test_chromoting_client.cc b/remoting/test/test_chromoting_client.cc index e1beedf..da19a6d 100644 --- a/remoting/test/test_chromoting_client.cc +++ b/remoting/test/test_chromoting_client.cc @@ -19,11 +19,11 @@ #include "remoting/client/token_fetcher_proxy.h" #include "remoting/protocol/chromium_port_allocator.h" #include "remoting/protocol/host_stub.h" -#include "remoting/protocol/ice_transport_factory.h" #include "remoting/protocol/negotiating_client_authenticator.h" #include "remoting/protocol/network_settings.h" #include "remoting/protocol/session_config.h" #include "remoting/protocol/third_party_client_authenticator.h" +#include "remoting/protocol/transport_context.h" #include "remoting/signaling/xmpp_signal_strategy.h" #include "remoting/test/connection_setup_info.h" #include "remoting/test/test_video_renderer.h" @@ -122,14 +122,13 @@ void TestChromotingClient::StartConnection( protocol::NetworkSettings network_settings( protocol::NetworkSettings::NAT_TRAVERSAL_FULL); - scoped_ptr port_allocator( - protocol::ChromiumPortAllocator::Create(request_context_getter, - network_settings)); + scoped_ptr port_allocator_factory( + new protocol::ChromiumPortAllocatorFactory(request_context_getter)); - scoped_ptr transport_factory( - new protocol::IceTransportFactory( - signal_strategy_.get(), port_allocator.Pass(), network_settings, - protocol::TransportRole::CLIENT)); + scoped_refptr transport_context( + new protocol::TransportContext( + signal_strategy_.get(), port_allocator_factory.Pass(), + network_settings, protocol::TransportRole::CLIENT)); scoped_ptr token_fetcher(new TokenFetcherProxy( @@ -153,7 +152,7 @@ void TestChromotingClient::StartConnection( connection_setup_info.auth_methods)); chromoting_client_->Start( - signal_strategy_.get(), authenticator.Pass(), transport_factory.Pass(), + signal_strategy_.get(), authenticator.Pass(), transport_context, connection_setup_info.host_jid, connection_setup_info.capabilities); } -- cgit v1.1