Enable TURN on the host when using WebRTC.

remoting/protocol/transport_context.cc

 // 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 <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 34 matching lines @@
     TransportRole role)
     : signal_strategy_(signal_strategy),
       port_allocator_factory_(std::move(port_allocator_factory)),
       url_request_factory_(std::move(url_request_factory)),
       network_settings_(network_settings),
       role_(role) {}
 
 TransportContext::~TransportContext() {}
 
 void TransportContext::Prepare() {
-  EnsureFreshJingleInfo();
+  EnsureFreshIceConfig();
 }
 
 void TransportContext::GetIceConfig(const GetIceConfigCallback& callback) {
-  EnsureFreshJingleInfo();
+  EnsureFreshIceConfig();
 
-  // If there is a pending |ice_config_request_| delay the callback until the
-  // request is finished.
-  if (ice_config_request_) {
-    pending_ice_config_callbacks_.push_back(callback);
+  // If there is a pending |ice_config_request_| for the current |relay_mode_|
+  // then delay the callback until the request is finished.
+  if (ice_config_request_[relay_mode_]) {
+    pending_ice_config_callbacks_[relay_mode_].push_back(callback);
   } else {
-    callback.Run(ice_config_);
+    callback.Run(ice_config_[relay_mode_]);
   }
 }
 
-void TransportContext::EnsureFreshJingleInfo() {
+void TransportContext::EnsureFreshIceConfig() {
   // Check if request is already pending.
-  if (ice_config_request_)
+  if (ice_config_request_[relay_mode_])
     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 (ice_config_.is_null() ||
-      base::Time::Now() > ice_config_.expiration_time) {
-    if (!ice_config_url_.empty()) {
-      ice_config_request_.reset(new HttpIceConfigRequest(
-          url_request_factory_.get(), ice_config_url_));
-    } else {
-      ice_config_request_.reset(new JingleInfoRequest(signal_strategy_));
+  if (ice_config_[relay_mode_].is_null() ||
+      base::Time::Now() > ice_config_[relay_mode_].expiration_time) {
+    scoped_ptr<IceConfigRequest> request;
+    switch (relay_mode_) {
+      case RelayMode::TURN:
+        if (ice_config_url_.empty()) {
+          LOG(WARNING) << "ice_config_url isn't set.";

[garykac, 2016/03/15 20:38:59]

Should this be an error? If the config url is not set, then it doesn't seem like
it's ensuring a fresh ice config.

[Sergey Ulanov, 2016/03/15 21:54:53]

There are cases when this URL won't be set and it's safe to ignore this issue.
Particularly for tests it's not set, but tests also don't need to use STUN or
TURN.

[garykac, 2016/03/16 00:58:21]

Acknowledged.

+          return;
+        }
+        request.reset(new HttpIceConfigRequest(url_request_factory_.get(),
+                                               ice_config_url_));
+        break;
+      case RelayMode::GTURN:
+        request.reset(new JingleInfoRequest(signal_strategy_));
+        break;
     }
-    ice_config_request_->Send(base::Bind(
-        &TransportContext::OnIceConfig, base::Unretained(this)));
+    ice_config_request_[relay_mode_] = std::move(request);
+    ice_config_request_[relay_mode_]->Send(base::Bind(
+        &TransportContext::OnIceConfig, base::Unretained(this), relay_mode_));
   }
 }
 
-void TransportContext::OnIceConfig(const IceConfig& ice_config) {
-  ice_config_ = ice_config;
-  ice_config_request_.reset();
+void TransportContext::OnIceConfig(RelayMode relay_mode,
+                                   const IceConfig& ice_config) {
+  ice_config_[relay_mode] = ice_config;
+  ice_config_request_[relay_mode].reset();
 
-  while (!pending_ice_config_callbacks_.empty()) {
-    pending_ice_config_callbacks_.begin()->Run(ice_config_);
-    pending_ice_config_callbacks_.pop_front();
+  auto& callback_list = pending_ice_config_callbacks_[relay_mode];
+  while (!callback_list.empty()) {
+    callback_list.begin()->Run(ice_config);
+    callback_list.pop_front();
   }
 }
 
 }  // namespace protocol
 }  // namespace remoting