Add mux-stream transport support in session description

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/logging.h"
 #include "base/string_number_conversions.h"
 #include "remoting/base/constants.h"
 #include "remoting/protocol/authenticator.h"
+#include "remoting/protocol/name_value_map.h"
 #include "third_party/libjingle/source/talk/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 kControlTag[] = "control";
 const char kEventTag[] = "event";
 const char kVideoTag[] = "video";
 const char kAudioTag[] = "audio";
 const char kDeprecatedResolutionTag[] = "initial-resolution";
 
 const char kTransportAttr[] = "transport";
 const char kVersionAttr[] = "version";
 const char kCodecAttr[] = "codec";
 const char kDeprecatedWidthAttr[] = "width";
 const char kDeprecatedHeightAttr[] = "height";
 
-const char kStreamTransport[] = "stream";
-const char kDatagramTransport[] = "datagram";
-const char kNoneTransport[] = "none";
+const NameMapElement<ChannelConfig::TransportType> kTransports[] = {
+  { ChannelConfig::TRANSPORT_STREAM, "stream" },
+  { ChannelConfig::TRANSPORT_STREAM, "mux-stream" },
+  { ChannelConfig::TRANSPORT_DATAGRAM, "datagram" },
+  { ChannelConfig::TRANSPORT_NONE, "none" },
+};
 
-const char kVerbatimCodec[] = "verbatim";
-const char kVp8Codec[] = "vp8";
-const char kZipCodec[] = "zip";
-const char kVorbisCodec[] = "vorbis";
-
-const char* GetTransportName(ChannelConfig::TransportType type) {
-  switch (type) {
-    case ChannelConfig::TRANSPORT_STREAM:
-      return kStreamTransport;
-    case ChannelConfig::TRANSPORT_DATAGRAM:
-      return kDatagramTransport;
-    case ChannelConfig::TRANSPORT_NONE:
-      return kNoneTransport;
-  }
-  NOTREACHED();
-  return NULL;
-}
-
-const char* GetCodecName(ChannelConfig::Codec type) {
-  switch (type) {
-    case ChannelConfig::CODEC_VERBATIM:
-      return kVerbatimCodec;
-    case ChannelConfig::CODEC_VP8:
-      return kVp8Codec;
-    case ChannelConfig::CODEC_ZIP:
-      return kZipCodec;
-    case ChannelConfig::CODEC_VORBIS:
-      return kVorbisCodec;
-    default:
-      break;
-  }
-  NOTREACHED();
-  return NULL;
-}
-
+const NameMapElement<ChannelConfig::Codec> kCodecs[] = {
+  { ChannelConfig::CODEC_VERBATIM, "verbatim" },
+  { ChannelConfig::CODEC_VP8, "vp8" },
+  { ChannelConfig::CODEC_ZIP, "zip" },
+  { ChannelConfig::CODEC_VORBIS, "vorbis" },
+};
 
 // Format a channel configuration tag for chromotocol session description,
 // e.g. for video channel:
 //    <video transport="stream" version="1" codec="vp8" />
 XmlElement* FormatChannelConfig(const ChannelConfig& config,
                                 const std::string& tag_name) {
   XmlElement* result = new XmlElement(
       QName(kChromotingXmlNamespace, tag_name));
 
   result->AddAttr(QName(kDefaultNs, kTransportAttr),
-                   GetTransportName(config.transport));
+                  ValueToName(kTransports, config.transport));
 
   result->AddAttr(QName(kDefaultNs, kVersionAttr),
                   base::IntToString(config.version));
 
   if (config.codec != ChannelConfig::CODEC_UNDEFINED) {
     result->AddAttr(QName(kDefaultNs, kCodecAttr),
-                    GetCodecName(config.codec));
+                    ValueToName(kCodecs, config.codec));
   }
 
   return result;
 }
 
-bool ParseTransportName(const std::string& value,
-                        ChannelConfig::TransportType* transport) {
-  if (value == kStreamTransport) {
-    *transport = ChannelConfig::TRANSPORT_STREAM;
-  } else if (value == kDatagramTransport) {
-    *transport = ChannelConfig::TRANSPORT_DATAGRAM;
-  } else if (value == kNoneTransport) {
-    *transport = ChannelConfig::TRANSPORT_NONE;
-  } else {
-    return false;
-  }
-  return true;
-}
-
-bool ParseCodecName(const std::string& value, ChannelConfig::Codec* codec) {
-  if (value == kVerbatimCodec) {
-    *codec = ChannelConfig::CODEC_VERBATIM;
-  } else if (value == kVp8Codec) {
-    *codec = ChannelConfig::CODEC_VP8;
-  } else if (value == kZipCodec) {
-    *codec = ChannelConfig::CODEC_ZIP;
-  } else if (value == kVorbisCodec) {
-    *codec = ChannelConfig::CODEC_VORBIS;
-  } else {
-    return false;
-  }
-  return true;
-}
-
 // Returns false if the element is invalid.
 bool ParseChannelConfig(const XmlElement* element, bool codec_required,
                         ChannelConfig* config) {
-  if (!ParseTransportName(element->Attr(QName(kDefaultNs, kTransportAttr)),
-                          &config->transport) ||
+  if (!NameToValue(
+          kTransports, element->Attr(QName(kDefaultNs, kTransportAttr)),
+          &config->transport) ||
       !base::StringToInt(element->Attr(QName(kDefaultNs, kVersionAttr)),
                          &config->version)) {
     return false;
   }
 
   if (codec_required) {
-    if (!ParseCodecName(element->Attr(QName(kDefaultNs, kCodecAttr)),
-                        &config->codec)) {
+    if (!NameToValue(kCodecs, element->Attr(QName(kDefaultNs, kCodecAttr)),
+                     &config->codec)) {
       return false;
     }
   } else {
     config->codec = ChannelConfig::CODEC_UNDEFINED;
   }
 
   return true;
 }
 
 }  // namespace
@@ skipping 121 matching lines @@
   const XmlElement* child = Authenticator::FindAuthenticatorMessage(element);
   if (child)
     authenticator_message.reset(new XmlElement(*child));
 
   return scoped_ptr<ContentDescription>(
       new ContentDescription(config.Pass(), authenticator_message.Pass()));
 }
 
 }  // namespace protocol
 }  // namespace remoting