Home | History | Annotate | Download | only in protocol 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "remoting/protocol/content_description.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/strings/string_number_conversions.h"
      9 #include "remoting/base/constants.h"
     10 #include "remoting/protocol/authenticator.h"
     11 #include "remoting/protocol/name_value_map.h"
     12 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
     13 
     14 using buzz::QName;
     15 using buzz::XmlElement;
     16 
     17 namespace remoting {
     18 namespace protocol {
     19 
     20 const char ContentDescription::kChromotingContentName[] = "chromoting";
     21 
     22 namespace {
     23 
     24 const char kDefaultNs[] = "";
     25 
     26 // Following constants are used to format session description in XML.
     27 const char kDescriptionTag[] = "description";
     28 const char kControlTag[] = "control";
     29 const char kEventTag[] = "event";
     30 const char kVideoTag[] = "video";
     31 const char kAudioTag[] = "audio";
     32 const char kDeprecatedResolutionTag[] = "initial-resolution";
     33 
     34 const char kTransportAttr[] = "transport";
     35 const char kVersionAttr[] = "version";
     36 const char kCodecAttr[] = "codec";
     37 const char kDeprecatedWidthAttr[] = "width";
     38 const char kDeprecatedHeightAttr[] = "height";
     39 
     40 const NameMapElement<ChannelConfig::TransportType> kTransports[] = {
     41   { ChannelConfig::TRANSPORT_STREAM, "stream" },
     42   { ChannelConfig::TRANSPORT_MUX_STREAM, "mux-stream" },
     43   { ChannelConfig::TRANSPORT_DATAGRAM, "datagram" },
     44   { ChannelConfig::TRANSPORT_NONE, "none" },
     45 };
     46 
     47 const NameMapElement<ChannelConfig::Codec> kCodecs[] = {
     48   { ChannelConfig::CODEC_VERBATIM, "verbatim" },
     49   { ChannelConfig::CODEC_VP8, "vp8" },
     50   { ChannelConfig::CODEC_VP9, "vp9" },
     51   { ChannelConfig::CODEC_ZIP, "zip" },
     52   { ChannelConfig::CODEC_OPUS, "opus" },
     53   { ChannelConfig::CODEC_SPEEX, "speex" },
     54 };
     55 
     56 // Format a channel configuration tag for chromotocol session description,
     57 // e.g. for video channel:
     58 //    <video transport="stream" version="1" codec="vp8" />
     59 XmlElement* FormatChannelConfig(const ChannelConfig& config,
     60                                 const std::string& tag_name) {
     61   XmlElement* result = new XmlElement(
     62       QName(kChromotingXmlNamespace, tag_name));
     63 
     64   result->AddAttr(QName(kDefaultNs, kTransportAttr),
     65                   ValueToName(kTransports, config.transport));
     66 
     67   if (config.transport != ChannelConfig::TRANSPORT_NONE) {
     68     result->AddAttr(QName(kDefaultNs, kVersionAttr),
     69                     base::IntToString(config.version));
     70 
     71     if (config.codec != ChannelConfig::CODEC_UNDEFINED) {
     72       result->AddAttr(QName(kDefaultNs, kCodecAttr),
     73                       ValueToName(kCodecs, config.codec));
     74     }
     75   }
     76 
     77   return result;
     78 }
     79 
     80 // Returns false if the element is invalid.
     81 bool ParseChannelConfig(const XmlElement* element, bool codec_required,
     82                         ChannelConfig* config) {
     83   if (!NameToValue(
     84           kTransports, element->Attr(QName(kDefaultNs, kTransportAttr)),
     85           &config->transport)) {
     86     return false;
     87   }
     88 
     89   // Version is not required when transport="none".
     90   if (config->transport != ChannelConfig::TRANSPORT_NONE) {
     91     if (!base::StringToInt(element->Attr(QName(kDefaultNs, kVersionAttr)),
     92                            &config->version)) {
     93       return false;
     94     }
     95 
     96     // Codec is not required when transport="none".
     97     if (codec_required) {
     98       if (!NameToValue(kCodecs, element->Attr(QName(kDefaultNs, kCodecAttr)),
     99                        &config->codec)) {
    100         return false;
    101       }
    102     } else {
    103       config->codec = ChannelConfig::CODEC_UNDEFINED;
    104     }
    105   } else {
    106     config->version = 0;
    107     config->codec = ChannelConfig::CODEC_UNDEFINED;
    108   }
    109 
    110   return true;
    111 }
    112 
    113 }  // namespace
    114 
    115 ContentDescription::ContentDescription(
    116     scoped_ptr<CandidateSessionConfig> config,
    117     scoped_ptr<buzz::XmlElement> authenticator_message)
    118     : candidate_config_(config.Pass()),
    119       authenticator_message_(authenticator_message.Pass()) {
    120 }
    121 
    122 ContentDescription::~ContentDescription() { }
    123 
    124 ContentDescription* ContentDescription::Copy() const {
    125   if (!candidate_config_.get() || !authenticator_message_.get()) {
    126     return NULL;
    127   }
    128   scoped_ptr<XmlElement> message(new XmlElement(*authenticator_message_));
    129   return new ContentDescription(candidate_config_->Clone(), message.Pass());
    130 }
    131 
    132 // ToXml() creates content description for chromoting session. The
    133 // description looks as follows:
    134 //   <description xmlns="google:remoting">
    135 //     <control transport="stream" version="1" />
    136 //     <event transport="datagram" version="1" />
    137 //     <video transport="stream" codec="vp8" version="1" />
    138 //     <audio transport="stream" codec="opus" version="1" />
    139 //     <authentication>
    140 //      Message created by Authenticator implementation.
    141 //     </authentication>
    142 //   </description>
    143 //
    144 XmlElement* ContentDescription::ToXml() const {
    145   XmlElement* root = new XmlElement(
    146       QName(kChromotingXmlNamespace, kDescriptionTag), true);
    147 
    148   std::list<ChannelConfig>::const_iterator it;
    149 
    150   for (it = config()->control_configs().begin();
    151        it != config()->control_configs().end(); ++it) {
    152     root->AddElement(FormatChannelConfig(*it, kControlTag));
    153   }
    154 
    155   for (it = config()->event_configs().begin();
    156        it != config()->event_configs().end(); ++it) {
    157     root->AddElement(FormatChannelConfig(*it, kEventTag));
    158   }
    159 
    160   for (it = config()->video_configs().begin();
    161        it != config()->video_configs().end(); ++it) {
    162     root->AddElement(FormatChannelConfig(*it, kVideoTag));
    163   }
    164 
    165   for (it = config()->audio_configs().begin();
    166        it != config()->audio_configs().end(); ++it) {
    167     ChannelConfig config = *it;
    168     root->AddElement(FormatChannelConfig(config, kAudioTag));
    169   }
    170 
    171   // Older endpoints require an initial-resolution tag, but otherwise ignore it.
    172   XmlElement* resolution_tag = new XmlElement(
    173       QName(kChromotingXmlNamespace, kDeprecatedResolutionTag));
    174   resolution_tag->AddAttr(QName(kDefaultNs, kDeprecatedWidthAttr), "640");
    175   resolution_tag->AddAttr(QName(kDefaultNs, kDeprecatedHeightAttr), "480");
    176   root->AddElement(resolution_tag);
    177 
    178   if (authenticator_message_.get()) {
    179     DCHECK(Authenticator::IsAuthenticatorMessage(authenticator_message_.get()));
    180     root->AddElement(new XmlElement(*authenticator_message_));
    181   }
    182 
    183   return root;
    184 }
    185 
    186 // static
    187 // Adds the channel configs corresponding to |tag_name|,
    188 // found in |element|, to |configs|.
    189 bool ContentDescription::ParseChannelConfigs(
    190     const XmlElement* const element,
    191     const char tag_name[],
    192     bool codec_required,
    193     bool optional,
    194     std::list<ChannelConfig>* const configs) {
    195 
    196   QName tag(kChromotingXmlNamespace, tag_name);
    197   const XmlElement* child = element->FirstNamed(tag);
    198   while (child) {
    199     ChannelConfig channel_config;
    200     if (ParseChannelConfig(child, codec_required, &channel_config)) {
    201       configs->push_back(channel_config);
    202     }
    203     child = child->NextNamed(tag);
    204   }
    205   if (optional && configs->empty()) {
    206       // If there's no mention of the tag, implicitly assume disabled channel.
    207       configs->push_back(ChannelConfig::None());
    208   }
    209   return true;
    210 }
    211 
    212 // static
    213 scoped_ptr<ContentDescription> ContentDescription::ParseXml(
    214     const XmlElement* element) {
    215   if (element->Name() != QName(kChromotingXmlNamespace, kDescriptionTag)) {
    216     LOG(ERROR) << "Invalid description: " << element->Str();
    217     return scoped_ptr<ContentDescription>();
    218   }
    219   scoped_ptr<CandidateSessionConfig> config(
    220       CandidateSessionConfig::CreateEmpty());
    221   if (!ParseChannelConfigs(element, kControlTag, false, false,
    222                            config->mutable_control_configs()) ||
    223       !ParseChannelConfigs(element, kEventTag, false, false,
    224                            config->mutable_event_configs()) ||
    225       !ParseChannelConfigs(element, kVideoTag, true, false,
    226                            config->mutable_video_configs()) ||
    227       !ParseChannelConfigs(element, kAudioTag, true, true,
    228                            config->mutable_audio_configs())) {
    229     return scoped_ptr<ContentDescription>();
    230   }
    231 
    232   scoped_ptr<XmlElement> authenticator_message;
    233   const XmlElement* child = Authenticator::FindAuthenticatorMessage(element);
    234   if (child)
    235     authenticator_message.reset(new XmlElement(*child));
    236 
    237   return scoped_ptr<ContentDescription>(
    238       new ContentDescription(config.Pass(), authenticator_message.Pass()));
    239 }
    240 
    241 }  // namespace protocol
    242 }  // namespace remoting
    243