[remoting][FTL] Use TURNaaS on Chromotocol when using FTL

Chromotocol uses STUN and TURN services provided by the Talk server,
which won't be available after the XMPP->FTL migration.

This CL forces the host and playground to use TURNaaS when
FtlSignalStrategy is being used.

The host and client are able to connect via relay for the first time but
subsequent connection will fail until we wait for ~5 minutes. This is a
known issue to Chromotocol even when using GTURN, while WebRTC doesn't
seem to be affected, even when using it on mobile clients.

Bug: 955617
Change-Id: I3799fb316c9861a57c7c019d85843f9211ef8242
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1584932
Commit-Queue: Yuwei Huang <yuweih@chromium.org>
Reviewed-by: Joe Downing <joedow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#654578}

remoting/client/chromoting_client.cc

@@ -89,7 +89,8 @@ void ChromotingClient::Start(
 #endif
     } else {
       DCHECK(protocol_config_->ice_supported());
-      connection_.reset(new protocol::IceConnectionToHost());
+      // TODO(yuweih): Pass true for FTL connection.
+      connection_.reset(new protocol::IceConnectionToHost(false));
     }
   }
   connection_->set_client_stub(this);

remoting/host/chromoting_host.cc

@@ -28,6 +28,7 @@
 #include "remoting/protocol/native_ip_synthesizer.h"
 #include "remoting/protocol/transport_context.h"
 #include "remoting/protocol/webrtc_connection_to_client.h"
+#include "remoting/signaling/signaling_address.h"
 
 using remoting::protocol::ConnectionToClient;
 using remoting::protocol::InputStub;
@@ -243,9 +244,11 @@ void ChromotingHost::OnIncomingSession(
         base::WrapUnique(session), transport_context_,
         video_encode_task_runner_, audio_task_runner_));
   } else {
+    SignalingAddress address(session->jid());
+    bool use_turn_api = address.channel() == SignalingAddress::Channel::FTL;
     connection.reset(new protocol::IceConnectionToClient(
         base::WrapUnique(session), transport_context_,
-        video_encode_task_runner_, audio_task_runner_));
+        video_encode_task_runner_, audio_task_runner_, use_turn_api));
   }
 
   // Create a ClientSession object.

remoting/protocol/connection_unittest.cc

@@ -300,8 +300,8 @@ class ConnectionTest : public testing::Test,
           base::WrapUnique(host_session_),
           TransportContext::ForTests(protocol::TransportRole::SERVER),
           scoped_task_environment_.GetMainThreadTaskRunner(),
-          scoped_task_environment_.GetMainThreadTaskRunner()));
-      client_connection_.reset(new IceConnectionToHost());
+          scoped_task_environment_.GetMainThreadTaskRunner(), false));
+      client_connection_.reset(new IceConnectionToHost(false));
     }
 
     // Setup host side.

remoting/protocol/ice_connection_to_client.cc

@@ -54,12 +54,13 @@ IceConnectionToClient::IceConnectionToClient(
     std::unique_ptr<protocol::Session> session,
     scoped_refptr<TransportContext> transport_context,
     scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner)
+    scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+    bool use_turn_api)
     : event_handler_(nullptr),
       session_(std::move(session)),
       video_encode_task_runner_(std::move(video_encode_task_runner)),
       audio_task_runner_(std::move(audio_task_runner)),
-      transport_(transport_context, this),
+      transport_(transport_context, this, use_turn_api),
       control_dispatcher_(new HostControlDispatcher()),
       event_dispatcher_(new HostEventDispatcher()),
       video_dispatcher_(new HostVideoDispatcher()) {

remoting/protocol/ice_connection_to_client.h

@@ -39,7 +39,8 @@ class IceConnectionToClient : public ConnectionToClient,
       std::unique_ptr<Session> session,
       scoped_refptr<TransportContext> transport_context,
       scoped_refptr<base::SingleThreadTaskRunner> video_encode_task_runner,
-      scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner,
+      bool use_turn_api);
   ~IceConnectionToClient() override;
 
   // ConnectionToClient interface.

remoting/protocol/ice_connection_to_host.cc

@@ -27,7 +27,9 @@
 namespace remoting {
 namespace protocol {
 
-IceConnectionToHost::IceConnectionToHost() = default;
+IceConnectionToHost::IceConnectionToHost(bool use_turn_api)
+    : use_turn_api_(use_turn_api) {}
+
 IceConnectionToHost::~IceConnectionToHost() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
@@ -40,7 +42,7 @@ void IceConnectionToHost::Connect(
   DCHECK(clipboard_stub_);
   DCHECK(video_renderer_);
 
-  transport_.reset(new IceTransport(transport_context, this));
+  transport_.reset(new IceTransport(transport_context, this, use_turn_api_));
 
   session_ = std::move(session);
   session_->SetEventHandler(this);

remoting/protocol/ice_connection_to_host.h

@@ -39,7 +39,7 @@ class IceConnectionToHost : public ConnectionToHost,
                             public IceTransport::EventHandler,
                             public ChannelDispatcherBase::EventHandler {
  public:
-  IceConnectionToHost();
+  IceConnectionToHost(bool use_turn_api);
   ~IceConnectionToHost() override;
 
   // ConnectionToHost interface.
@@ -105,6 +105,10 @@ class IceConnectionToHost : public ConnectionToHost,
   State state_ = INITIALIZING;
   ErrorCode error_ = OK;
 
+  // If this is true, ICE connection will use TURN API instead of the gTalk TURN
+  // services to allocate relay sessions.
+  bool use_turn_api_;
+
  private:
   SEQUENCE_CHECKER(sequence_checker_);
 

remoting/protocol/ice_transport.cc

@@ -26,11 +26,14 @@ const int kTransportInfoSendDelayMs = 20;
 static const char kMuxChannelName[] = "mux";
 
 IceTransport::IceTransport(scoped_refptr<TransportContext> transport_context,
-                           EventHandler* event_handler)
+                           EventHandler* event_handler,
+                           bool use_turn_api)
     : transport_context_(transport_context),
       event_handler_(event_handler),
       weak_factory_(this) {
-  transport_context_->set_relay_mode(TransportContext::RelayMode::GTURN);
+  transport_context_->set_relay_mode(use_turn_api
+                                         ? TransportContext::RelayMode::TURN
+                                         : TransportContext::RelayMode::GTURN);
   transport_context->Prepare();
 }
 

remoting/protocol/ice_transport.h

@@ -39,8 +39,12 @@ class IceTransport : public Transport,
   };
 
   // |transport_context| must outlive the session.
+  // If |use_turn_api| is true, ICE connection will use TURN API instead of the
+  // gTalk TURN services to allocate relay sessions.
+  // TODO(yuweih): Remove |use_turn_api| once the XMPP->FTL transition is done.
   IceTransport(scoped_refptr<TransportContext> transport_context,
-               EventHandler* event_handler);
+               EventHandler* event_handler,
+               bool use_turn_api);
   ~IceTransport() override;
 
   MessageChannelFactory* GetChannelFactory();

remoting/protocol/ice_transport_unittest.cc

@@ -118,7 +118,7 @@ class IceTransportTest : public testing::Test {
         new TransportContext(nullptr,
                              std::make_unique<ChromiumPortAllocatorFactory>(),
                              nullptr, network_settings_, TransportRole::SERVER),
-        &host_event_handler_));
+        &host_event_handler_, false));
     if (!host_authenticator_) {
       host_authenticator_.reset(
           new FakeAuthenticator(FakeAuthenticator::ACCEPT));
@@ -128,7 +128,7 @@ class IceTransportTest : public testing::Test {
         new TransportContext(nullptr,
                              std::make_unique<ChromiumPortAllocatorFactory>(),
                              nullptr, network_settings_, TransportRole::CLIENT),
-        &client_event_handler_));
+        &client_event_handler_, false));
     if (!client_authenticator_) {
       client_authenticator_.reset(
           new FakeAuthenticator(FakeAuthenticator::ACCEPT));

remoting/test/fake_ice_connection.cc

@@ -16,7 +16,7 @@ FakeIceConnection::FakeIceConnection(
     scoped_refptr<protocol::TransportContext> transport_context,
     base::OnceClosure on_closed) {
   transport_ =
-      std::make_unique<protocol::IceTransport>(transport_context, this);
+      std::make_unique<protocol::IceTransport>(transport_context, this, true);
   on_closed_ = std::move(on_closed);
   if (transport_context->role() == protocol::TransportRole::CLIENT) {
     control_dispatcher_ = std::make_unique<protocol::ClientControlDispatcher>();

remoting/test/ftl_signaling_playground.cc

@@ -256,8 +256,6 @@ void FtlSignalingPlayground::InitializeTransport() {
       std::make_unique<ChromiumUrlRequestFactory>(
           url_loader_factory_owner_->GetURLLoaderFactory()),
       network_settings, transport_role_);
-  transport_context->set_relay_mode(
-      protocol::TransportContext::RelayMode::TURN);
   transport_context->set_ice_config_url(
       ServiceUrls::GetInstance()->ice_config_url(), token_getter_.get());
   auto close_callback =