Use standard ICE in Chromoting.

remoting/protocol/session_config.cc

Index: remoting/protocol/session_config.cc
diff --git a/remoting/protocol/session_config.cc b/remoting/protocol/session_config.cc
index 460da2807bfa7bd13b1cbdbca1eac2b837b08e66..f6163f4fa8df622d07e92dfa5ce85620ec484416 100644
--- a/remoting/protocol/session_config.cc
+++ b/remoting/protocol/session_config.cc
@@ -9,6 +9,30 @@
 namespace remoting {
 namespace protocol {
 
+namespace {
+
+bool IsChannelConfigSupported(const std::list<ChannelConfig>& list,
+                              const ChannelConfig& value) {
+  return std::find(list.begin(), list.end(), value) != list.end();
+}
+
+bool SelectCommonChannelConfig(const std::list<ChannelConfig>& host_configs,
+                               const std::list<ChannelConfig>& client_configs,
+                               ChannelConfig* config) {
+  // Usually each of these lists will contain just a few elements, so iterating
+  // over all of them is not a problem.
+  std::list<ChannelConfig>::const_iterator it;
+  for (it = client_configs.begin(); it != client_configs.end(); ++it) {
+    if (IsChannelConfigSupported(host_configs, *it)) {
+      *config = *it;
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
 const int kDefaultStreamVersion = 2;
 const int kControlStreamVersion = 3;
 
@@ -16,12 +40,6 @@ ChannelConfig ChannelConfig::None() {
   return ChannelConfig();
 }
 
-ChannelConfig::ChannelConfig()
-    : transport(TRANSPORT_NONE),
-      version(0),
-      codec(CODEC_UNDEFINED) {
-}
-
 ChannelConfig::ChannelConfig(TransportType transport, int version, Codec codec)
     : transport(transport),
       version(version),
@@ -35,32 +53,93 @@ bool ChannelConfig::operator==(const ChannelConfig& b) const {
   return transport == b.transport && version == b.version && codec == b.codec;
 }
 
-SessionConfig::SessionConfig() {
+// static
+scoped_ptr<SessionConfig> SessionConfig::SelectCommon(
+    const CandidateSessionConfig* client_config,
+    const CandidateSessionConfig* host_config) {
+  scoped_ptr<SessionConfig> result(new SessionConfig());
+  ChannelConfig control_config;
+  ChannelConfig event_config;
+  ChannelConfig video_config;
+  ChannelConfig audio_config;
+
+  result->standard_ice_ =
+      host_config->standard_ice() && client_config->standard_ice();
+
+  if (!SelectCommonChannelConfig(host_config->control_configs(),
+                                 client_config->control_configs(),
+                                 &result->control_config_) ||
+      !SelectCommonChannelConfig(host_config->event_configs(),
+                                 client_config->event_configs(),
+                                 &result->event_config_) ||
+      !SelectCommonChannelConfig(host_config->video_configs(),
+                                 client_config->video_configs(),
+                                 &result->video_config_) ||
+      !SelectCommonChannelConfig(host_config->audio_configs(),
+                                 client_config->audio_configs(),
+                                 &result->audio_config_)) {
+    return nullptr;
+  }
+
+  return result;
 }
 
 // static
-SessionConfig SessionConfig::ForTest() {
-  SessionConfig result;
-  result.set_control_config(ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
+scoped_ptr<SessionConfig> SessionConfig::GetFinalConfig(
+    const CandidateSessionConfig* candidate_config) {
+  if (candidate_config->control_configs().size() != 1 ||
+      candidate_config->event_configs().size() != 1 ||
+      candidate_config->video_configs().size() != 1 ||
+      candidate_config->audio_configs().size() != 1) {
+    return nullptr;
+  }
+
+  scoped_ptr<SessionConfig> result(new SessionConfig());
+  result->standard_ice_ = candidate_config->standard_ice();
+  result->control_config_ = candidate_config->control_configs().front();
+  result->event_config_ = candidate_config->event_configs().front();
+  result->video_config_ = candidate_config->video_configs().front();
+  result->audio_config_ = candidate_config->audio_configs().front();
+
+  return result.Pass();
+}
+
+// static
+scoped_ptr<SessionConfig> SessionConfig::ForTest() {
+  scoped_ptr<SessionConfig> result(new SessionConfig());
+  result->standard_ice_ = true;
+  result->control_config_ = ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                                           kControlStreamVersion,
-                                          ChannelConfig::CODEC_UNDEFINED));
-  result.set_event_config(ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
+                                          ChannelConfig::CODEC_UNDEFINED);
+  result->event_config_ = ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                                         kDefaultStreamVersion,
-                                        ChannelConfig::CODEC_UNDEFINED));
-  result.set_video_config(ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+                                        ChannelConfig::CODEC_UNDEFINED);
+  result->video_config_ = ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
                                         kDefaultStreamVersion,
-                                        ChannelConfig::CODEC_VP8));
-  result.set_audio_config(ChannelConfig(ChannelConfig::TRANSPORT_NONE,
+                                        ChannelConfig::CODEC_VP8);
+  result->audio_config_ = ChannelConfig(ChannelConfig::TRANSPORT_NONE,
                                         kDefaultStreamVersion,
-                                        ChannelConfig::CODEC_UNDEFINED));
-  return result;
+                                        ChannelConfig::CODEC_UNDEFINED);
+  return result.Pass();
 }
 
+// static
+scoped_ptr<SessionConfig> SessionConfig::WithLegacyIceForTest() {
+  scoped_ptr<SessionConfig> result = ForTest();
+  result->standard_ice_ = false;
+  return result.Pass();
+}
+
+SessionConfig::SessionConfig() {
+}
+
+
 CandidateSessionConfig::CandidateSessionConfig() { }
 
 CandidateSessionConfig::CandidateSessionConfig(
     const CandidateSessionConfig& config)
-    : control_configs_(config.control_configs_),
+    : standard_ice_(true),
+      control_configs_(config.control_configs_),
       event_configs_(config.event_configs_),
       video_configs_(config.video_configs_),
       audio_configs_(config.audio_configs_) {
@@ -68,33 +147,6 @@ CandidateSessionConfig::CandidateSessionConfig(
 
 CandidateSessionConfig::~CandidateSessionConfig() { }
 
-bool CandidateSessionConfig::Select(
-    const CandidateSessionConfig* client_config,
-    SessionConfig* result) {
-  ChannelConfig control_config;
-  ChannelConfig event_config;
-  ChannelConfig video_config;
-  ChannelConfig audio_config;
-
-  if (!SelectCommonChannelConfig(
-          control_configs_, client_config->control_configs_, &control_config) ||
-      !SelectCommonChannelConfig(
-          event_configs_, client_config->event_configs_, &event_config) ||
-      !SelectCommonChannelConfig(
-          video_configs_, client_config->video_configs_, &video_config) ||
-      !SelectCommonChannelConfig(
-          audio_configs_, client_config->audio_configs_, &audio_config)) {
-    return false;
-  }
-
-  result->set_control_config(control_config);
-  result->set_event_config(event_config);
-  result->set_video_config(video_config);
-  result->set_audio_config(audio_config);
-
-  return true;
-}
-
 bool CandidateSessionConfig::IsSupported(
     const SessionConfig& config) const {
   return
@@ -104,46 +156,6 @@ bool CandidateSessionConfig::IsSupported(
       IsChannelConfigSupported(audio_configs_, config.audio_config());
 }
 
-bool CandidateSessionConfig::GetFinalConfig(SessionConfig* result) const {
-  if (control_configs_.size() != 1 ||
-      event_configs_.size() != 1 ||
-      video_configs_.size() != 1 ||
-      audio_configs_.size() != 1) {
-    return false;
-  }
-
-  result->set_control_config(control_configs_.front());
-  result->set_event_config(event_configs_.front());
-  result->set_video_config(video_configs_.front());
-  result->set_audio_config(audio_configs_.front());
-
-  return true;
-}
-
-// static
-bool CandidateSessionConfig::SelectCommonChannelConfig(
-    const std::list<ChannelConfig>& host_configs,
-    const std::list<ChannelConfig>& client_configs,
-    ChannelConfig* config) {
-  // Usually each of these vectors will contain just several elements,
-  // so iterating over all of them is not a problem.
-  std::list<ChannelConfig>::const_iterator it;
-  for (it = client_configs.begin(); it != client_configs.end(); ++it) {
-    if (IsChannelConfigSupported(host_configs, *it)) {
-      *config = *it;
-      return true;
-    }
-  }
-  return false;
-}
-
-// static
-bool CandidateSessionConfig::IsChannelConfigSupported(
-    const std::list<ChannelConfig>& vector,
-    const ChannelConfig& value) {
-  return std::find(vector.begin(), vector.end(), value) != vector.end();
-}
-
 scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::Clone() const {
   return make_scoped_ptr(new CandidateSessionConfig(*this));
 }
@@ -157,6 +169,7 @@ scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateEmpty() {
 scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateFrom(
     const SessionConfig& config) {
   scoped_ptr<CandidateSessionConfig> result = CreateEmpty();
+  result->set_standard_ice(config.standard_ice());
   result->mutable_control_configs()->push_back(config.control_config());
   result->mutable_event_configs()->push_back(config.event_config());
   result->mutable_video_configs()->push_back(config.video_config());
@@ -168,6 +181,8 @@ scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateFrom(
 scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateDefault() {
   scoped_ptr<CandidateSessionConfig> result = CreateEmpty();
 
+  result->set_standard_ice(true);
+
   // Control channel.
   result->mutable_control_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,