Enable QUIC support in chromoting

remoting/protocol/session_config.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "remoting/protocol/session_config.h"
 
 #include <algorithm>
+#include <vector>
 
 #include "base/logging.h"
 
 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;
 }
 
+void UpdateConfigListToPreferTransport(std::list<ChannelConfig>* configs,
+                                       ChannelConfig::TransportType transport) {
+  std::vector<ChannelConfig> sorted(configs->begin(), configs->end());
+  std::stable_sort(sorted.begin(), sorted.end(),
+                   [transport](const ChannelConfig& a, const ChannelConfig& b) {
+                     // |a| must precede |b| if |a| uses preferred transport and
+                     // |b| doesn't.
+                     return a.transport == transport &&
+                            b.transport != transport;
+                   });
+  configs->assign(sorted.begin(), sorted.end());
+}
+
 }  // namespace
 
 const int kDefaultStreamVersion = 2;
 const int kControlStreamVersion = 3;
 
 ChannelConfig ChannelConfig::None() {
   return ChannelConfig();
 }
 
 ChannelConfig::ChannelConfig(TransportType transport, int version, Codec codec)
@@ skipping 69 matching lines @@
   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->control_config_ = ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
+  result->control_config_ = ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
                                           kControlStreamVersion,
                                           ChannelConfig::CODEC_UNDEFINED);
-  result->event_config_ = ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
+  result->event_config_ = ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_UNDEFINED);
-  result->video_config_ = ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
+  result->video_config_ = ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_VP8);
   result->audio_config_ = ChannelConfig(ChannelConfig::TRANSPORT_NONE,
                                         kDefaultStreamVersion,
                                         ChannelConfig::CODEC_UNDEFINED);
   return result.Pass();
 }
 
 SessionConfig::SessionConfig() {}
 
@@ skipping 33 matching lines @@
 
 // static
 scoped_ptr<CandidateSessionConfig> CandidateSessionConfig::CreateDefault() {
   scoped_ptr<CandidateSessionConfig> result = CreateEmpty();
 
   // Control channel.
   result->mutable_control_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                     kControlStreamVersion,
                     ChannelConfig::CODEC_UNDEFINED));
+  result->mutable_control_configs()->push_back(
+      ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
+                    kControlStreamVersion,
+                    ChannelConfig::CODEC_UNDEFINED));
 
   // Event channel.
   result->mutable_event_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                     kDefaultStreamVersion,
                     ChannelConfig::CODEC_UNDEFINED));
+  result->mutable_event_configs()->push_back(
+      ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
+                    kDefaultStreamVersion,
+                    ChannelConfig::CODEC_UNDEFINED));
 
   // Video channel.
   result->mutable_video_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
                     kDefaultStreamVersion,
                     ChannelConfig::CODEC_VP9));
   result->mutable_video_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_STREAM,
                     kDefaultStreamVersion,
                     ChannelConfig::CODEC_VP8));
+  result->mutable_video_configs()->push_back(
+      ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
+                    kDefaultStreamVersion,
+                    ChannelConfig::CODEC_VP9));
+  result->mutable_video_configs()->push_back(
+      ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
+                    kDefaultStreamVersion,
+                    ChannelConfig::CODEC_VP8));
 
   // Audio channel.
   result->mutable_audio_configs()->push_back(
       ChannelConfig(ChannelConfig::TRANSPORT_MUX_STREAM,
                     kDefaultStreamVersion,
                     ChannelConfig::CODEC_OPUS));
+  result->mutable_audio_configs()->push_back(
+      ChannelConfig(ChannelConfig::TRANSPORT_QUIC_STREAM,
+                    kDefaultStreamVersion,
+                    ChannelConfig::CODEC_OPUS));
   result->mutable_audio_configs()->push_back(ChannelConfig::None());
 
   return result.Pass();
 }
 
 void CandidateSessionConfig::DisableAudioChannel() {
   mutable_audio_configs()->clear();
   mutable_audio_configs()->push_back(ChannelConfig());
 }
 
+void CandidateSessionConfig::PreferTransport(
+    ChannelConfig::TransportType transport) {
+  UpdateConfigListToPreferTransport(&control_configs_, transport);
+  UpdateConfigListToPreferTransport(&event_configs_, transport);
+  UpdateConfigListToPreferTransport(&video_configs_, transport);
+  UpdateConfigListToPreferTransport(&audio_configs_, transport);
+}
+
 }  // namespace protocol
 }  // namespace remoting