Enable QUIC support in chromoting

remoting/protocol/content_description.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/content_description.h"
 
+#include "base/base64.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
 #include "remoting/protocol/name_value_map.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 using buzz::QName;
 using buzz::XmlElement;
 
 namespace remoting {
 namespace protocol {
 
 const char ContentDescription::kChromotingContentName[] = "chromoting";
 
 namespace {
 
 const char kDefaultNs[] = "";
 
 // Following constants are used to format session description in XML.
 const char kDescriptionTag[] = "description";
 const char kStandardIceTag[] = "standard-ice";
 const char kControlTag[] = "control";
 const char kEventTag[] = "event";
 const char kVideoTag[] = "video";
 const char kAudioTag[] = "audio";
 const char kVp9ExperimentTag[] = "vp9-experiment";
 const char kDeprecatedResolutionTag[] = "initial-resolution";
+const char kQuicConfigTag[] = "quic-config";
 
 const char kTransportAttr[] = "transport";
 const char kVersionAttr[] = "version";
 const char kCodecAttr[] = "codec";
 const char kDeprecatedWidthAttr[] = "width";
 const char kDeprecatedHeightAttr[] = "height";
 
 const NameMapElement<ChannelConfig::TransportType> kTransports[] = {
   { ChannelConfig::TRANSPORT_STREAM, "stream" },
   { ChannelConfig::TRANSPORT_MUX_STREAM, "mux-stream" },
+  { ChannelConfig::TRANSPORT_QUIC_STREAM, "quic-stream" },
   { ChannelConfig::TRANSPORT_DATAGRAM, "datagram" },
   { ChannelConfig::TRANSPORT_NONE, "none" },
 };
 
 const NameMapElement<ChannelConfig::Codec> kCodecs[] = {
   { ChannelConfig::CODEC_VERBATIM, "verbatim" },
   { ChannelConfig::CODEC_VP8, "vp8" },
   { ChannelConfig::CODEC_VP9, "vp9" },
   { ChannelConfig::CODEC_ZIP, "zip" },
   { ChannelConfig::CODEC_OPUS, "opus" },
@@ skipping 54 matching lines @@
     config->codec = ChannelConfig::CODEC_UNDEFINED;
   }
 
   return true;
 }
 
 }  // namespace
 
 ContentDescription::ContentDescription(
     scoped_ptr<CandidateSessionConfig> config,
-    scoped_ptr<buzz::XmlElement> authenticator_message)
+    scoped_ptr<buzz::XmlElement> authenticator_message,
+    const std::string& quic_config_message)
     : candidate_config_(config.Pass()),
-      authenticator_message_(authenticator_message.Pass()) {
+      authenticator_message_(authenticator_message.Pass()),
+      quic_config_message_(quic_config_message) {
 }
 
 ContentDescription::~ContentDescription() { }
 
 // ToXml() creates content description for chromoting session. The
 // description looks as follows:
 //   <description xmlns="google:remoting">
 //     <standard-ice/>
 //     <control transport="stream" version="1" />
 //     <event transport="datagram" version="1" />
@@ skipping 29 matching lines @@
     root->AddElement(FormatChannelConfig(channel_config, kAudioTag));
   }
 
   // Older endpoints require an initial-resolution tag, but otherwise ignore it.
   XmlElement* resolution_tag = new XmlElement(
       QName(kChromotingXmlNamespace, kDeprecatedResolutionTag));
   resolution_tag->AddAttr(QName(kDefaultNs, kDeprecatedWidthAttr), "640");
   resolution_tag->AddAttr(QName(kDefaultNs, kDeprecatedHeightAttr), "480");
   root->AddElement(resolution_tag);
 
-  if (authenticator_message_.get()) {
+  if (authenticator_message_) {
     DCHECK(Authenticator::IsAuthenticatorMessage(authenticator_message_.get()));
     root->AddElement(new XmlElement(*authenticator_message_));
   }
 
+  if (!quic_config_message_.empty()) {
+    XmlElement* quic_config_tag =
+        new XmlElement(QName(kChromotingXmlNamespace, kQuicConfigTag));
+    root->AddElement(quic_config_tag);
+    std::string config_base64;
+    base::Base64Encode(quic_config_message_, &config_base64);
+    quic_config_tag->SetBodyText(config_base64);
+  }
+
   if (config()->vp9_experiment_enabled()) {
     root->AddElement(
         new XmlElement(QName(kChromotingXmlNamespace, kVp9ExperimentTag)));
   }
 
   return root;
 }
 
 // static
 // Adds the channel configs corresponding to |tag_name|,
@@ skipping 48 matching lines @@
   // Check if VP9 experiment is enabled.
   if (element->FirstNamed(QName(kChromotingXmlNamespace, kVp9ExperimentTag))) {
     config->set_vp9_experiment_enabled(true);
   }
 
   scoped_ptr<XmlElement> authenticator_message;
   const XmlElement* child = Authenticator::FindAuthenticatorMessage(element);
   if (child)
     authenticator_message.reset(new XmlElement(*child));
 
-  return make_scoped_ptr(
-      new ContentDescription(config.Pass(), authenticator_message.Pass()));
+  std::string quic_config_message;
+  const XmlElement* quic_config_tag =
+      element->FirstNamed(QName(kChromotingXmlNamespace, kQuicConfigTag));
+  if (quic_config_tag) {
+    if (!base::Base64Decode(quic_config_tag->BodyText(),
+                            &quic_config_message)) {
+      LOG(ERROR) << "Failed to parse QUIC config.";
+      return nullptr;
+    }
+  }
+
+  return make_scoped_ptr(new ContentDescription(
+      config.Pass(), authenticator_message.Pass(), quic_config_message));
 }
 
 }  // namespace protocol
 }  // namespace remoting